Safe Haskell	None
Language	Haskell2010

Cardano.Prelude

Synopsis

forceElemsToWHNF :: Foldable t => t a -> t a
parseJSString :: forall a m e. ( Typeable a, ReportSchemaErrors m, Buildable e) => ( Text -> Either e a) -> JSValue -> m a
data SchemaError = SchemaError {
- seExpected :: ! Text
- seActual :: !( Maybe Text )
}
canonicalDecodePretty :: forall a. FromJSON ( Either SchemaError ) a => ByteString -> Either Text a
canonicalEncodePretty :: forall a. ToJSON Identity a => a -> ByteString
class HeapWords a where
- heapWords :: a -> Int
heapSizeMb :: Int -> Int
heapSizeKb :: Int -> Int
heapWords0 :: Int
heapWords1 :: HeapWords a => a -> Int
heapWords2 :: ( HeapWords a1, HeapWords a) => a -> a1 -> Int
heapWords3 :: ( HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> Int
heapWords4 :: ( HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> Int
heapWords5 :: ( HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> Int
heapWords6 :: ( HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> Int
heapWords7 :: ( HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> Int
heapWords8 :: ( HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> Int
heapWords9 :: ( HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> Int
heapWords10 :: ( HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> Int
heapWords11 :: ( HeapWords a10, HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> Int
heapWords12 :: ( HeapWords a11, HeapWords a10, HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> Int
heapWords13 :: ( HeapWords a12, HeapWords a11, HeapWords a10, HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> Int
heapWordsUArray :: ( Ix i, IArray a e) => Int -> a i e -> Int
heapWordsUVector :: Unbox e => Int -> Vector e -> Int
heapWordsUnpacked :: HeapWords a => a -> Int
data ClosureTreeOptions = ClosureTreeOptions {
- ctoMaxDepth :: ! TreeDepth
- ctoCyclicClosures :: ! TraverseCyclicClosures
}
data TraverseCyclicClosures
- = TraverseCyclicClosures
- | NoTraverseCyclicClosures
data TreeDepth
- = TreeDepth ! Int
- | AnyDepth
buildClosureTree :: ClosureTreeOptions -> a -> IO ( Maybe ( Tree Closure ))
buildAndRenderClosureTree :: ClosureTreeOptions -> a -> IO Text
depth :: Tree a -> Int
isZeroOrNegativeTreeDepth :: TreeDepth -> Bool
renderClosure :: Closure -> Text
renderTree :: Tree a -> (a -> Text ) -> Text
data CountFailure
- = WorkListFull
- | VisitedFull
- | OutOfMemory
- | UnsupportedClosure ClosureType
data PerformGC
- = FirstPerformGC
- | DontPerformGC
computeHeapSize :: a -> IO ( Either CountFailure Word64 )
computeHeapSize' :: PerformGC -> Word -> Word -> Word -> a -> IO ( Either CountFailure Word64 )
computeHeapSizeWorkList :: a -> Word64
isHeadNormalForm :: Closure -> IO Bool
isNormalForm :: a -> IO Bool
base16Builder :: ByteString -> Builder
base16F :: Format r ( ByteString -> r)
pairF :: ( Buildable a, Buildable b) => Format r ((a, b) -> r)
pairBuilder :: ( Buildable a, Buildable b) => (a, b) -> Builder
listJson :: ( Foldable t, Buildable a) => Format r (t a -> r)
listJsonIndent :: ( Foldable t, Buildable a) => Word -> Format r (t a -> r)
mapJson :: ( IsList t, Item t ~ (k, v), Buildable k, Buildable v) => Format r (t -> r)
toAesonError :: Buildable e => Either e a -> Parser a
aesonError :: Buildable e => e -> Parser a
toCborError :: Buildable e => Either e a -> Decoder s a
cborError :: Buildable e => e -> Decoder s a
wrapError :: MonadError e' m => Either e a -> (e -> e') -> m a
orThrowError :: MonadError e m => Bool -> e -> m ()
(++) :: [a] -> [a] -> [a]
seq :: forall (r :: RuntimeRep ) a (b :: TYPE r). a -> b -> b
filter :: (a -> Bool ) -> [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
fst :: (a, b) -> a
snd :: (a, b) -> b
otherwise :: Bool
($) :: forall (r :: RuntimeRep ) a (b :: TYPE r). (a -> b) -> a -> b
fromIntegral :: ( Integral a, Num b) => a -> b
realToFrac :: ( Real a, Fractional b) => a -> b
guard :: Alternative f => Bool -> f ()
join :: Monad m => m (m a) -> m a
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 Eq a where
- (==) :: a -> a -> Bool
- (/=) :: a -> a -> Bool
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
- log1p :: a -> a
- expm1 :: a -> a
- log1pexp :: a -> a
- log1mexp :: a -> a
class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
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 Applicative m => Monad (m :: Type -> Type ) where
- (>>=) :: m a -> (a -> m b) -> m b
- (>>) :: m a -> m b -> m b
- return :: a -> m a
class Functor (f :: Type -> Type ) where
- fmap :: (a -> b) -> f a -> f b
- (<$) :: a -> f b -> f 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 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
class Read a
class ( Num a, Ord a) => Real a where
- toRational :: a -> Rational
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 ( 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 Show a
class Typeable (a :: k)
class Monad m => MonadFail (m :: Type -> Type )
class IsString 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 Foldable (t :: Type -> Type ) where
- fold :: Monoid m => t m -> m
- foldMap :: Monoid m => (a -> m) -> t a -> m
- foldr :: (a -> b -> b) -> b -> t a -> b
- foldr' :: (a -> b -> b) -> b -> t a -> b
- foldl :: (b -> a -> b) -> b -> t a -> b
- foldl' :: (b -> a -> b) -> b -> t a -> b
- toList :: 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
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)
class Generic a where
- type Rep a :: Type -> Type
- from :: a -> Rep a x
- to :: Rep a x -> a
class Generic1 (f :: k -> Type )
class Datatype (d :: k) where
- datatypeName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> [ Char ]
- moduleName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> [ Char ]
- packageName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> [ Char ]
- isNewtype :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> Bool
class Constructor (c :: k) where
- conName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t c f a -> [ Char ]
- conFixity :: forall k1 t (f :: k1 -> Type ) (a :: k1). t c f a -> Fixity
- conIsRecord :: forall k1 t (f :: k1 -> Type ) (a :: k1). t c f a -> Bool
class Selector (s :: k) where
- selName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> [ Char ]
- selSourceUnpackedness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> SourceUnpackedness
- selSourceStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> SourceStrictness
- selDecidedStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> DecidedStrictness
class KnownNat (n :: Nat )
class KnownSymbol (n :: Symbol )
class IsLabel (x :: Symbol ) a where
- fromLabel :: a
class Semigroup a where
- (<>) :: a -> a -> a
- sconcat :: NonEmpty a -> a
- stimes :: Integral b => b -> a -> a
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
class HasField (x :: k) r a | x r -> a where
- getField :: r -> a
data Bool
- = False
- | True
data Char
data Double = D# Double#
data Float = F# Float#
data Int
data Int8
data Int16
data Int32
data Int64
data Integer
data Natural
data Maybe a
- = Nothing
- | Just a
data Ordering
- = LT
- | EQ
- | GT
data Ratio a
type Rational = Ratio Integer
data StablePtr a
data IO a
data Word
data Word8
data Word16
data Word32
data Word64
data Ptr a
data FunPtr a
data Either a b
- = Left a
- | Right b
type Type = Type
data Constraint
data V1 (p :: k)
data U1 (p :: k) = U1
newtype K1 i c (p :: k) = K1 {
- unK1 :: c
}
newtype M1 i (c :: Meta ) (f :: k -> Type ) (p :: k) = M1 {
- unM1 :: f p
}
data ((f :: k -> Type ) :+: (g :: k -> Type )) (p :: k)
- = L1 (f p)
- | R1 (g p)
data ((f :: k -> Type ) :*: (g :: k -> Type )) (p :: k) = (f p) :*: (g p)
newtype ((f :: k2 -> Type ) :.: (g :: k1 -> k2)) (p :: k1) = Comp1 {
- unComp1 :: f (g p)
}
type Rec0 = K1 R :: Type -> k -> Type
type D1 = M1 D :: Meta -> (k -> Type ) -> k -> Type
type C1 = M1 C :: Meta -> (k -> Type ) -> k -> Type
type S1 = M1 S :: Meta -> (k -> Type ) -> k -> Type
type family Rep a :: Type -> Type
data family URec a (p :: k)
data Nat
data Symbol
type family CmpNat (a :: Nat ) (b :: Nat ) :: Ordering where ...
class a ~R# b => Coercible (a :: k) (b :: k)
data StaticPtr a
data CallStack
data ByteString
(<$>) :: Functor f => (a -> b) -> f a -> f b
const :: a -> b -> a
toLower :: Char -> Char
data Text
data Map k a
data Handle
data ST s a
class Bifunctor (p :: Type -> Type -> Type ) where
- bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
- first :: (a -> b) -> p a c -> p b c
- second :: (b -> c) -> p a b -> p a c
forM_ :: ( Foldable t, Monad m) => t a -> (a -> m b) -> m ()
mapM_ :: ( Foldable t, Monad m) => (a -> m b) -> t a -> m ()
forkOnWithUnmask :: Int -> (( forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
forkIOWithUnmask :: (( forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
forkOn :: Int -> IO () -> IO ThreadId
forkOS :: IO () -> IO ThreadId
forkIO :: IO () -> IO ThreadId
data ThreadId
concurrently :: IO a -> IO b -> IO (a, b)
race_ :: IO a -> IO b -> IO ()
race :: IO a -> IO b -> IO ( Either a b)
link2 :: Async a -> Async b -> IO ()
link :: Async a -> IO ()
waitBoth :: Async a -> Async b -> IO (a, b)
waitEitherCancel :: Async a -> Async b -> IO ( Either a b)
waitEither_ :: Async a -> Async b -> IO ()
waitEither :: Async a -> Async b -> IO ( Either a b)
waitEitherCatchCancel :: Async a -> Async b -> IO ( Either ( Either SomeException a) ( Either SomeException b))
waitEitherCatch :: Async a -> Async b -> IO ( Either ( Either SomeException a) ( Either SomeException b))
waitAnyCancel :: [ Async a] -> IO ( Async a, a)
waitAny :: [ Async a] -> IO ( Async a, a)
waitAnyCatchCancel :: [ Async a] -> IO ( Async a, Either SomeException a)
waitAnyCatch :: [ Async a] -> IO ( Async a, Either SomeException a)
cancelWith :: Exception e => Async a -> e -> IO ()
cancel :: Async a -> IO ()
poll :: Async a -> IO ( Maybe ( Either SomeException a))
waitCatch :: Async a -> IO ( Either SomeException a)
wait :: Async a -> IO a
withAsyncOn :: Int -> IO a -> ( Async a -> IO b) -> IO b
withAsyncBound :: IO a -> ( Async a -> IO b) -> IO b
withAsync :: IO a -> ( Async a -> IO b) -> IO b
asyncOn :: Int -> IO a -> IO ( Async a)
asyncBound :: IO a -> IO ( Async a)
async :: IO a -> IO ( Async a)
data Async a
newtype Concurrently a = Concurrently {
- runConcurrently :: IO a
}
isSpace :: Char -> Bool
isAlpha :: Char -> Bool
isDigit :: Char -> Bool
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 ( Alternative m, Monad m) => MonadPlus (m :: Type -> Type ) where
- mzero :: m a
- mplus :: m a -> m a -> m a
phase :: RealFloat a => Complex a -> a
magnitude :: RealFloat a => Complex a -> a
polar :: RealFloat a => Complex a -> (a, a)
cis :: Floating a => a -> Complex a
mkPolar :: Floating a => a -> a -> Complex a
conjugate :: Num a => Complex a -> Complex a
imagPart :: Complex a -> a
realPart :: Complex a -> a
data Complex a = !a :+ !a
vacuous :: Functor f => f Void -> f a
absurd :: Void -> a
data Void
option :: b -> (a -> b) -> Option a -> b
mtimesDefault :: ( Integral b, Monoid a) => b -> a -> a
diff :: Semigroup m => m -> Endo m
cycle1 :: Semigroup m => m -> m
data WrappedMonoid m
newtype Option a = Option {
- getOption :: Maybe a
}
threadWaitWriteSTM :: Fd -> IO ( STM (), IO ())
threadWaitReadSTM :: Fd -> IO ( STM (), IO ())
threadWaitWrite :: Fd -> IO ()
threadWaitRead :: Fd -> IO ()
runInUnboundThread :: IO a -> IO a
runInBoundThread :: IO a -> IO a
isCurrentThreadBound :: IO Bool
forkOSWithUnmask :: (( forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
forkFinally :: IO a -> ( Either SomeException a -> IO ()) -> IO ThreadId
rtsSupportsBoundThreads :: Bool
writeList2Chan :: Chan a -> [a] -> IO ()
getChanContents :: Chan a -> IO [a]
dupChan :: Chan a -> IO ( Chan a)
readChan :: Chan a -> IO a
writeChan :: Chan a -> a -> IO ()
newChan :: IO ( Chan a)
data Chan a
signalQSem :: QSem -> IO ()
waitQSem :: QSem -> IO ()
newQSem :: Int -> IO QSem
data QSem
signalQSemN :: QSemN -> Int -> IO ()
waitQSemN :: QSemN -> Int -> IO ()
newQSemN :: Int -> IO QSemN
data QSemN
nonEmpty :: [a] -> Maybe ( NonEmpty a)
showStackTrace :: IO ( Maybe String )
getStackTrace :: IO ( Maybe [ Location ])
data SrcLoc = SrcLoc String Int Int
data Location = Location {
- objectName :: String
- functionName :: String
- srcLoc :: Maybe SrcLoc
}
class Monad m => MonadIO (m :: Type -> Type ) where
- liftIO :: IO a -> m a
getArgs :: IO [ String ]
exitSuccess :: IO a
exitFailure :: IO a
exitWith :: ExitCode -> IO a
mfilter :: MonadPlus m => (a -> Bool ) -> m a -> m a
(<$!>) :: Monad m => (a -> b) -> m a -> m b
unless :: Applicative f => Bool -> f () -> f ()
replicateM_ :: Applicative m => Int -> m a -> m ()
replicateM :: Applicative m => Int -> m a -> m [a]
foldM_ :: ( Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
foldM :: ( Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
forever :: Applicative f => f a -> f b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
filterM :: Applicative m => (a -> m Bool ) -> [a] -> m [a]
foldMapDefault :: ( Traversable t, Monoid m) => (a -> m) -> t a -> m
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
forM :: ( Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
for :: ( Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
optional :: Alternative f => f a -> f ( Maybe a)
newtype ZipList a = ZipList {
- getZipList :: [a]
}
newtype Identity a = Identity {
- runIdentity :: a
}
withFile :: FilePath -> IOMode -> ( Handle -> IO r) -> IO r
openFile :: FilePath -> IOMode -> IO Handle
stderr :: Handle
stdin :: Handle
threadDelay :: Int -> IO ()
mkWeakMVar :: MVar a -> IO () -> IO ( Weak ( MVar a))
addMVarFinalizer :: MVar a -> IO () -> IO ()
modifyMVarMasked :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO ()
modifyMVar :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVar_ :: MVar a -> (a -> IO a) -> IO ()
withMVarMasked :: MVar a -> (a -> IO b) -> IO b
withMVar :: MVar a -> (a -> IO b) -> IO b
swapMVar :: MVar a -> a -> IO a
withFrozenCallStack :: HasCallStack => ( HasCallStack => a) -> a
callStack :: HasCallStack => CallStack
allowInterrupt :: IO ()
catches :: IO a -> [ Handler a] -> IO a
data Handler a = Exception e => Handler (e -> IO a)
fixST :: (a -> ST s a) -> ST s a
bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket_ :: IO a -> IO b -> IO c -> IO c
finally :: IO a -> IO b -> IO a
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
onException :: IO a -> IO b -> IO a
tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO ( Either b a)
try :: Exception e => IO a -> IO ( Either e a)
mapException :: ( Exception e1, Exception e2) => (e1 -> e2) -> a -> a
handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
handle :: Exception e => (e -> IO a) -> IO a -> IO a
catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
newtype PatternMatchFail = PatternMatchFail String
newtype RecSelError = RecSelError String
newtype RecConError = RecConError String
newtype RecUpdError = RecUpdError String
newtype NoMethodError = NoMethodError String
newtype TypeError = TypeError String
data NonTermination = NonTermination
data NestedAtomically = NestedAtomically
catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
throwSTM :: Exception e => e -> STM a
orElse :: STM a -> STM a -> STM a
retry :: STM a
atomically :: STM a -> IO a
mkWeakThreadId :: ThreadId -> IO ( Weak ThreadId )
threadCapability :: ThreadId -> IO ( Int , Bool )
yield :: IO ()
myThreadId :: IO ThreadId
killThread :: ThreadId -> IO ()
setNumCapabilities :: Int -> IO ()
getNumCapabilities :: IO Int
data STM a
ioError :: IOError -> IO a
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
asyncExceptionToException :: Exception e => e -> SomeException
data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
data Deadlock = Deadlock
data AllocationLimitExceeded = AllocationLimitExceeded
newtype CompactionFailed = CompactionFailed String
newtype AssertionFailed = AssertionFailed String
data SomeAsyncException = Exception e => SomeAsyncException e
data AsyncException
- = StackOverflow
- | HeapOverflow
- | ThreadKilled
- | UserInterrupt
data ArrayException
- = IndexOutOfBounds String
- | UndefinedElement String
data ExitCode
- = ExitSuccess
- | ExitFailure Int
stdout :: Handle
evaluate :: a -> IO a
uninterruptibleMask :: (( forall a. IO a -> IO a) -> IO b) -> IO b
uninterruptibleMask_ :: IO a -> IO a
mask :: (( forall a. IO a -> IO a) -> IO b) -> IO b
mask_ :: IO a -> IO a
getMaskingState :: IO MaskingState
interruptible :: IO a -> IO a
catch :: Exception e => IO a -> (e -> IO a) -> IO a
type FilePath = String
data MaskingState
- = Unmasked
- | MaskedInterruptible
- | MaskedUninterruptible
data IOException
prettyCallStack :: CallStack -> String
prettySrcLoc :: SrcLoc -> String
data ErrorCall where
- ErrorCallWithLocation String String
- pattern ErrorCall :: String -> ErrorCall
class ( Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
data ArithException
- = Overflow
- | Underflow
- | LossOfPrecision
- | DivideByZero
- | Denormal
- | RatioZeroDenominator
gcast :: forall k (a :: k) (b :: k) c. ( Typeable a, Typeable b) => c a -> Maybe (c b)
eqT :: forall k (a :: k) (b :: k). ( Typeable a, Typeable b) => Maybe (a :~: b)
cast :: ( Typeable a, Typeable b) => a -> Maybe b
typeRep :: forall k proxy (a :: k). Typeable a => proxy a -> TypeRep
typeOf :: Typeable a => a -> TypeRep
type TypeRep = SomeTypeRep
newtype Const a (b :: k) = Const {
- getConst :: a
}
find :: Foldable t => (a -> Bool ) -> t a -> Maybe a
notElem :: ( Foldable t, Eq a) => a -> t a -> Bool
minimumBy :: Foldable t => (a -> a -> Ordering ) -> t a -> a
maximumBy :: Foldable t => (a -> a -> Ordering ) -> t a -> a
all :: Foldable t => (a -> Bool ) -> t a -> Bool
any :: Foldable t => (a -> Bool ) -> t a -> Bool
or :: Foldable t => t Bool -> Bool
and :: Foldable t => t Bool -> Bool
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
concat :: Foldable t => t [a] -> [a]
msum :: ( Foldable t, MonadPlus m) => t (m a) -> m a
asum :: ( Foldable t, Alternative f) => t (f a) -> f a
sequence_ :: ( Foldable t, Monad m) => t (m a) -> m ()
sequenceA_ :: ( Foldable t, Applicative f) => t (f a) -> f ()
for_ :: ( Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
traverse_ :: ( Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
foldlM :: ( Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldrM :: ( Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
newtype First a = First {
- getFirst :: Maybe a
}
newtype Last a = Last {
- getLast :: Maybe a
}
newtype Ap (f :: k -> Type ) (a :: k) = Ap {
- getAp :: f a
}
stimesMonoid :: ( Integral b, Monoid a) => b -> a -> a
stimesIdempotent :: Integral b => b -> a -> a
newtype Dual a = Dual {
- getDual :: a
}
newtype Endo a = Endo {
- appEndo :: a -> a
}
newtype All = All {
- getAll :: Bool
}
newtype Any = Any {
- getAny :: Bool
}
newtype Sum a = Sum {
- getSum :: a
}
newtype Product a = Product {
- getProduct :: a
}
newtype Alt (f :: k -> Type ) (a :: k) = Alt {
- getAlt :: f a
}
data Fixity
- = Prefix
- | Infix Associativity Int
data FixityI
- = PrefixI
- | InfixI Associativity Nat
data Associativity
- = LeftAssociative
- | RightAssociative
- | NotAssociative
data Meta
- = MetaData Symbol Symbol Symbol Bool
- | MetaCons Symbol FixityI Bool
- | MetaSel ( Maybe Symbol ) SourceUnpackedness SourceStrictness DecidedStrictness
someSymbolVal :: String -> SomeSymbol
someNatVal :: Integer -> Maybe SomeNat
symbolVal :: forall (n :: Symbol ) proxy. KnownSymbol n => proxy n -> String
natVal :: forall (n :: Nat ) proxy. KnownNat n => proxy n -> Integer
data SomeSymbol = KnownSymbol n => SomeSymbol ( Proxy n)
data SomeNat = KnownNat n => SomeNat ( Proxy n)
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
sortBy :: (a -> a -> Ordering ) -> [a] -> [a]
sort :: Ord a => [a] -> [a]
permutations :: [a] -> [[a]]
subsequences :: [a] -> [[a]]
tails :: [a] -> [[a]]
inits :: [a] -> [[a]]
groupBy :: (a -> a -> Bool ) -> [a] -> [[a]]
group :: Eq a => [a] -> [[a]]
genericReplicate :: Integral i => i -> a -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericDrop :: Integral i => i -> [a] -> [a]
genericTake :: Integral i => i -> [a] -> [a]
genericLength :: Num i => [a] -> i
transpose :: [[a]] -> [[a]]
intercalate :: [a] -> [[a]] -> [a]
intersperse :: a -> [a] -> [a]
isPrefixOf :: Eq a => [a] -> [a] -> Bool
isLetter :: Char -> Bool
digitToInt :: Char -> Int
readMaybe :: Read a => String -> Maybe a
readEither :: Read a => String -> Either String a
reads :: Read a => ReadS a
fromRight :: b -> Either a b -> b
fromLeft :: a -> Either a b -> a
isRight :: Either a b -> Bool
isLeft :: Either a b -> Bool
partitionEithers :: [ Either a b] -> ([a], [b])
rights :: [ Either a b] -> [b]
lefts :: [ Either a b] -> [a]
either :: (a -> c) -> (b -> c) -> Either a b -> c
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
newtype Down a = Down a
data Proxy (t :: k) = Proxy
(>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
(<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
class Category (cat :: k -> k -> Type ) where
- (.) :: forall (b :: k) (c :: k) (a :: k). cat b c -> cat a b -> cat a c
repr :: forall k (a :: k) (b :: k). (a :~: b) -> Coercion a b
coerceWith :: Coercion a b -> a -> b
data Coercion (a :: k) (b :: k) where
- Coercion :: forall k (a :: k) (b :: k). Coercible a b => Coercion a b
gcastWith :: forall k (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r
castWith :: (a :~: b) -> a -> b
trans :: forall k (a :: k) (b :: k) (c :: k). (a :~: b) -> (b :~: c) -> a :~: c
sym :: forall k (a :: k) (b :: k). (a :~: b) -> b :~: a
data (a :: k) :~: (b :: k) where
- Refl :: forall k (a :: k). a :~: a
type family (a :: k) == (b :: k) :: Bool where ...
data WordPtr
data IntPtr
data IOMode
- = ReadMode
- | WriteMode
- | AppendMode
- | ReadWriteMode
class Storable a
byteSwap64 :: Word64 -> Word64
byteSwap32 :: Word32 -> Word32
byteSwap16 :: Word16 -> Word16
toTitle :: Char -> Char
toUpper :: Char -> Char
isLower :: Char -> Bool
isUpper :: Char -> Bool
isPrint :: Char -> Bool
isControl :: Char -> Bool
isAlphaNum :: Char -> Bool
isHexDigit :: Char -> Bool
isAscii :: Char -> Bool
toIntegralSized :: ( Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
popCountDefault :: ( Bits a, Num a) => a -> Int
testBitDefault :: ( Bits a, Num a) => a -> Int -> Bool
bitDefault :: ( Bits a, Num a) => Int -> a
class Eq a => Bits a where
- (.&.) :: a -> a -> a
- (.|.) :: 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
- shiftR :: a -> Int -> a
- rotateL :: a -> Int -> a
- rotateR :: a -> Int -> a
- popCount :: a -> Int
class Bits b => FiniteBits b where
- finiteBitSize :: b -> Int
- countLeadingZeros :: b -> Int
- countTrailingZeros :: b -> Int
integralEnumFromThenTo :: Integral a => a -> a -> a -> [a]
integralEnumFromTo :: Integral a => a -> a -> [a]
integralEnumFromThen :: ( Integral a, Bounded a) => a -> a -> [a]
integralEnumFrom :: ( Integral a, Bounded a) => a -> [a]
gcdWord' :: Word -> Word -> Word
gcdInt' :: Int -> Int -> Int
lcm :: Integral a => a -> a -> a
gcd :: Integral a => a -> a -> a
(^^%^^) :: Integral a => Rational -> a -> Rational
(^%^) :: Integral a => Rational -> a -> Rational
(^^) :: ( Fractional a, Integral b) => a -> b -> a
(^) :: ( Num a, Integral b) => a -> b -> a
odd :: Integral a => a -> Bool
even :: Integral a => a -> Bool
numericEnumFromThenTo :: ( Ord a, Fractional a) => a -> a -> a -> [a]
numericEnumFromTo :: ( Ord a, Fractional a) => a -> a -> [a]
numericEnumFromThen :: Fractional a => a -> a -> [a]
numericEnumFrom :: Fractional a => a -> [a]
denominator :: Ratio a -> a
numerator :: Ratio a -> a
(%) :: Integral a => a -> a -> Ratio a
reduce :: Integral a => a -> a -> Ratio a
notANumber :: Rational
infinity :: Rational
ratioPrec1 :: Int
ratioPrec :: Int
underflowError :: a
overflowError :: a
ratioZeroDenominatorError :: a
divZeroError :: a
boundedEnumFromThen :: ( Enum a, Bounded a) => a -> a -> [a]
boundedEnumFrom :: ( Enum a, Bounded a) => a -> [a]
chr :: Int -> Char
runST :: ( forall s. ST s a) -> a
intToDigit :: Int -> Char
unzip :: [(a, b)] -> ([a], [b])
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
reverse :: [a] -> [a]
break :: (a -> Bool ) -> [a] -> ([a], [a])
splitAt :: Int -> [a] -> ([a], [a])
drop :: Int -> [a] -> [a]
take :: Int -> [a] -> [a]
dropWhile :: (a -> Bool ) -> [a] -> [a]
takeWhile :: (a -> Bool ) -> [a] -> [a]
cycle :: [a] -> [a]
replicate :: Int -> a -> [a]
repeat :: a -> [a]
iterate :: (a -> a) -> a -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanl' :: (b -> a -> b) -> b -> [a] -> [b]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
catMaybes :: [ Maybe a] -> [a]
listToMaybe :: [a] -> Maybe a
maybeToList :: Maybe a -> [a]
fromMaybe :: a -> Maybe a -> a
isNothing :: Maybe a -> Bool
isJust :: Maybe a -> Bool
maybe :: b -> (a -> b) -> Maybe a -> b
(&) :: a -> (a -> b) -> b
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
fix :: (a -> a) -> a
void :: Functor f => f a -> f ()
($>) :: Functor f => f a -> b -> f b
(<&>) :: Functor f => f a -> (a -> b) -> f b
swap :: (a, b) -> (b, a)
uncurry :: (a -> b -> c) -> (a, b) -> c
curry :: ((a, b) -> c) -> a -> b -> c
isEmptyMVar :: MVar a -> IO Bool
tryReadMVar :: MVar a -> IO ( Maybe a)
tryPutMVar :: MVar a -> a -> IO Bool
tryTakeMVar :: MVar a -> IO ( Maybe a)
putMVar :: MVar a -> a -> IO ()
readMVar :: MVar a -> IO a
takeMVar :: MVar a -> IO a
newMVar :: a -> IO ( MVar a)
newEmptyMVar :: IO ( MVar a)
data MVar a
subtract :: Num a => a -> a -> a
currentCallStack :: IO [ String ]
asTypeOf :: a -> a -> a
until :: (a -> Bool ) -> (a -> a) -> a -> a
flip :: (a -> b -> c) -> b -> a -> c
maxInt :: Int
minInt :: Int
ord :: Char -> Int
ap :: Monad m => m (a -> b) -> m a -> m b
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
when :: Applicative f => Bool -> f () -> f ()
(=<<) :: Monad m => (a -> m b) -> m a -> m b
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA :: Applicative f => (a -> b) -> f a -> f b
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
data NonEmpty a = a :| [a]
getCallStack :: CallStack -> [([ Char ], SrcLoc )]
type HasCallStack = ?callStack :: CallStack
stimesIdempotentMonoid :: ( Integral b, Monoid a) => b -> a -> a
data SomeException = Exception e => SomeException e
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
data IntMap a
data IntSet
data Seq a
data Set a
force :: NFData a => a -> a
($!!) :: NFData a => (a -> b) -> a -> b
deepseq :: NFData a => a -> b -> b
class NFData a where
- rnf :: a -> ()
lift :: ( MonadTrans t, Monad m) => m a -> t m a
gets :: MonadState s m => (s -> a) -> m a
modify :: MonadState s m => (s -> s) -> m ()
class Monad m => MonadState s (m :: Type -> Type ) | m -> s where
- get :: m s
- put :: s -> m ()
- state :: (s -> (a, s)) -> m a
asks :: MonadReader r m => (r -> a) -> m a
class Monad m => MonadReader r (m :: Type -> Type ) | m -> r where
- ask :: m r
- local :: (r -> r) -> m a -> m a
- reader :: (r -> a) -> m a
class Monad m => MonadError e (m :: Type -> Type ) | m -> e where
- throwError :: e -> m a
- catchError :: m a -> (e -> m a) -> m a
newtype ExceptT e (m :: Type -> Type ) a = ExceptT (m ( Either e a))
type Except e = ExceptT e Identity
runExcept :: Except e a -> Either e a
mapExcept :: ( Either e a -> Either e' b) -> Except e a -> Except e' b
withExcept :: (e -> e') -> Except e a -> Except e' a
runExceptT :: ExceptT e m a -> m ( Either e a)
mapExceptT :: (m ( Either e a) -> n ( Either e' b)) -> ExceptT e m a -> ExceptT e' n b
withExceptT :: forall (m :: Type -> Type ) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
newtype ReaderT r (m :: Type -> Type ) a = ReaderT {
- runReaderT :: r -> m a
}
type Reader r = ReaderT r Identity
runReader :: Reader r a -> r -> a
newtype StateT s (m :: Type -> Type ) a = StateT {
- runStateT :: s -> m (a, s)
}
type State s = StateT s Identity
runState :: State s a -> s -> (a, s)
evalState :: State s a -> s -> a
execState :: State s a -> s -> s
withState :: (s -> s) -> State s a -> State s a
evalStateT :: Monad m => StateT s m a -> s -> m a
execStateT :: Monad m => StateT s m a -> s -> m s
die :: Text -> IO a
show :: ( Show a, ConvertText String b) => a -> b
liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c
liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b
guardedA :: ( Functor f, Alternative t) => (a -> f Bool ) -> a -> f (t a)
guarded :: Alternative f => (a -> Bool ) -> a -> f a
pass :: Applicative f => f ()
throwTo :: ( MonadIO m, Exception e) => ThreadId -> e -> m ()
throwIO :: ( MonadIO m, Exception e) => e -> m a
print :: ( MonadIO m, Show a) => a -> m ()
applyN :: Int -> (a -> a) -> a -> a
unsnoc :: [x] -> Maybe ([x], x)
uncons :: [a] -> Maybe (a, [a])
map :: Functor f => (a -> b) -> f a -> f b
type LText = Text
type LByteString = ByteString
undefined :: a
notImplemented :: a
traceId :: Text -> Text
traceM :: Monad m => Text -> m ()
traceShowM :: ( Show a, Monad m) => a -> m ()
traceShowId :: Show a => a -> a
traceShow :: Show a => a -> b -> b
traceIO :: Print b => b -> a -> IO a
trace :: Print b => b -> a -> a
putErrText :: MonadIO m => Text -> m ()
putLByteString :: MonadIO m => ByteString -> m ()
putByteString :: MonadIO m => ByteString -> m ()
putLText :: MonadIO m => Text -> m ()
putText :: MonadIO m => Text -> m ()
class Print a where
- hPutStr :: MonadIO m => Handle -> a -> m ()
- putStr :: MonadIO m => a -> m ()
- hPutStrLn :: MonadIO m => Handle -> a -> m ()
- putStrLn :: MonadIO m => a -> m ()
- putErrLn :: MonadIO m => a -> m ()
zero :: Monoid m => m
class Monoid m => Semiring m where
- one :: m
- (<.>) :: m -> m -> m
atDef :: a -> [a] -> Int -> a
atMay :: [a] -> Int -> Maybe a
foldl1May' :: (a -> a -> a) -> [a] -> Maybe a
foldl1May :: (a -> a -> a) -> [a] -> Maybe a
foldr1May :: (a -> a -> a) -> [a] -> Maybe a
maximumDef :: Ord a => a -> [a] -> a
minimumDef :: Ord a => a -> [a] -> a
maximumMay :: Ord a => [a] -> Maybe a
minimumMay :: Ord a => [a] -> Maybe a
lastDef :: a -> [a] -> a
lastMay :: [a] -> Maybe a
tailSafe :: [a] -> [a]
tailDef :: [a] -> [a] -> [a]
tailMay :: [a] -> Maybe [a]
initSafe :: [a] -> [a]
initDef :: [a] -> [a] -> [a]
initMay :: [a] -> Maybe [a]
headDef :: a -> [a] -> a
headMay :: [a] -> Maybe a
panic :: HasCallStack => Text -> a
newtype FatalError = FatalError {
- fatalErrorMessage :: Text
}
liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c
liftM' :: Monad m => (a -> b) -> m a -> m b
concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
sum :: ( Foldable f, Num a) => f a -> a
product :: ( Foldable f, Num a) => f a -> a
list :: [b] -> (a -> b) -> [a] -> [b]
ordNub :: Ord a => [a] -> [a]
sortOn :: Ord o => (a -> o) -> [a] -> [a]
head :: Foldable f => f a -> Maybe a
foreach :: Functor f => f a -> (a -> b) -> f b
(<<$>>) :: ( Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
tryIO :: forall (m :: Type -> Type ) a. MonadIO m => IO a -> ExceptT IOException m a
note :: MonadError e m => e -> Maybe a -> m a
hush :: Alternative m => Either e a -> m a
maybeToEither :: e -> Maybe a -> Either e a
maybeEmpty :: Monoid b => (a -> b) -> Maybe a -> b
maybeToLeft :: r -> Maybe l -> Either l r
maybeToRight :: l -> Maybe r -> Either l r
rightToMaybe :: Either l r -> Maybe r
leftToMaybe :: Either l r -> Maybe l
toUtf8Lazy :: ConvertText a Text => a -> ByteString
toUtf8 :: ConvertText a Text => a -> ByteString
class ConvertText a b where
- toS :: a -> b
(<&&>) :: Applicative a => a Bool -> a Bool -> a Bool
(&&^) :: Monad m => m Bool -> m Bool -> m Bool
(<||>) :: Applicative a => a Bool -> a Bool -> a Bool
(||^) :: Monad m => m Bool -> m Bool -> m Bool
guardM :: MonadPlus m => m Bool -> m ()
ifM :: Monad m => m Bool -> m a -> m a -> m a
unlessM :: Monad m => m Bool -> m () -> m ()
whenM :: Monad m => m Bool -> m () -> m ()
bool :: a -> a -> Bool -> a
($!) :: (a -> b) -> a -> b
(<<*>>) :: ( Applicative f, Applicative g) => f (g (a -> b)) -> f (g a) -> f (g b)
liftAA2 :: ( Applicative f, Applicative g) => (a -> b -> c) -> f (g a) -> f (g b) -> f (g c)
purer :: ( Applicative f, Applicative g) => a -> f (g a)
eitherA :: Alternative f => f a -> f b -> f ( Either a b)
orEmpty :: Alternative f => Bool -> a -> f a
orAlt :: ( Alternative f, Monoid a) => f a -> f a
throwE :: forall (m :: Type -> Type ) e a. Monad m => e -> ExceptT e m a
catchE :: forall (m :: Type -> Type ) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
data UnicodeException
type OnDecodeError = OnError Word8 Char
type OnError a b = String -> Maybe a -> Maybe b
strictDecode :: OnDecodeError
lenientDecode :: OnDecodeError
ignore :: OnError a b
replace :: b -> OnError a b
decodeUtf8With :: OnDecodeError -> ByteString -> Text
decodeUtf8 :: ByteString -> Text
decodeUtf8' :: ByteString -> Either UnicodeException Text
encodeUtf8 :: Text -> ByteString
words :: Text -> [ Text ]
lines :: Text -> [ Text ]
unlines :: [ Text ] -> Text
unwords :: [ Text ] -> Text
toStrict :: Text -> Text
fromStrict :: Text -> Text
readFile :: FilePath -> IO Text
writeFile :: FilePath -> Text -> IO ()
appendFile :: FilePath -> Text -> IO ()
interact :: ( Text -> Text ) -> IO ()
getContents :: IO Text
getLine :: IO Text
check :: Bool -> STM ()
identity :: Category cat => cat a a
putTextLn :: Text -> IO ()
length :: HasLength a => a -> Int

Documentation

forceElemsToWHNF :: Foldable t => t a -> t a Source #

Force all of the elements of a Foldable to weak head normal form.

In order to ensure that all of the elements of a Foldable are strict, we can simply foldMap over it and seq each value with () . However, () 's mappend implementation is actually completely lazy: _ <> _ = () So, in order to work around this, we instead utilize this newly defined StrictUnit whose mappend implementation is specifically strict.

parseJSString :: forall a m e. ( Typeable a, ReportSchemaErrors m, Buildable e) => ( Text -> Either e a) -> JSValue -> m a Source #

Attempt to parse a value of type a from the body of a JSString using parser

data SchemaError Source #

Constructors

SchemaError
Fields seExpected :: ! Text seActual :: !( Maybe Text )

Instances

Instances details

Eq SchemaError Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods (==) :: SchemaError -> SchemaError -> Bool Source # (/=) :: SchemaError -> SchemaError -> Bool Source #
Show SchemaError Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods showsPrec :: Int -> SchemaError -> ShowS Source # show :: SchemaError -> String Source # showList :: [ SchemaError ] -> ShowS Source #
Buildable SchemaError Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods build :: SchemaError -> Builder Source #

canonicalDecodePretty :: forall a. FromJSON ( Either SchemaError ) a => ByteString -> Either Text a Source #

canonicalEncodePretty :: forall a. ToJSON Identity a => a -> ByteString Source #

class HeapWords a where Source #

Size in the heap of values, in words (to get the size in bytes multiply by 4 on a 32-bit machine or 8 on a 64-bit machine)

Methods

heapWords :: a -> Int Source #

Instances

Instances details

HeapWords Bool Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Bool -> Int Source #
HeapWords Char Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Char -> Int Source #
HeapWords Float Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Float -> Int Source #
HeapWords Int Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Int -> Int Source #
HeapWords Integer Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Integer -> Int Source #
HeapWords Natural Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Natural -> Int Source #
HeapWords Word Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word -> Int Source #
HeapWords Word8 Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word8 -> Int Source #
HeapWords Word32 Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word32 -> Int Source #
HeapWords Word64 Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word64 -> Int Source #
HeapWords ByteString Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: ByteString -> Int Source #
HeapWords UTCTime Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: UTCTime -> Int Source #
HeapWords Text Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Text -> Int Source #
HeapWords ShortByteString Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: ShortByteString -> Int Source #
HeapWords IntSet Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: IntSet -> Int Source #
HeapWords BigNat Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: BigNat -> Int Source #
HeapWords LByteString Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: LByteString -> Int Source #
HeapWords Day Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Day -> Int Source #
HeapWords a => HeapWords [a] Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: [a] -> Int Source #
HeapWords a => HeapWords ( Maybe a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Maybe a -> Int Source #
HeapWords a => HeapWords ( IntMap a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: IntMap a -> Int Source #
HeapWords a => HeapWords ( Seq a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Seq a -> Int Source #
HeapWords a => HeapWords ( Set a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Set a -> Int Source #
HeapWords e => HeapWords ( Vector e) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Vector e -> Int Source #
HeapWords (a -> b) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: (a -> b) -> Int Source #
( HeapWords a, HeapWords b) => HeapWords ( Either a b) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Either a b -> Int Source #
( HeapWords a, HeapWords b) => HeapWords (a, b) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: (a, b) -> Int Source #
( HeapWords a, HeapWords b) => HeapWords ( Map a b) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Map a b -> Int Source #
( HeapWords a, HeapWords b, HeapWords c) => HeapWords (a, b, c) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: (a, b, c) -> Int Source #
( HeapWords a, HeapWords b, HeapWords c, HeapWords d) => HeapWords (a, b, c, d) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: (a, b, c, d) -> Int Source #

heapSizeMb :: Int -> Int Source #

These functions assume a 64-bit architecture

heapSizeKb :: Int -> Int Source #

These functions assume a 64-bit architecture

heapWords0 :: Int Source #

heapWords1 :: HeapWords a => a -> Int Source #

heapWords2 :: ( HeapWords a1, HeapWords a) => a -> a1 -> Int Source #

heapWords3 :: ( HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> Int Source #

heapWords4 :: ( HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> Int Source #

heapWords5 :: ( HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> Int Source #

heapWords6 :: ( HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> Int Source #

heapWords7 :: ( HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> Int Source #

heapWords8 :: ( HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> Int Source #

heapWords9 :: ( HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> Int Source #

heapWords10 :: ( HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> Int Source #

heapWords11 :: ( HeapWords a10, HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> Int Source #

heapWords12 :: ( HeapWords a11, HeapWords a10, HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> Int Source #

heapWords13 :: ( HeapWords a12, HeapWords a11, HeapWords a10, HeapWords a9, HeapWords a8, HeapWords a7, HeapWords a6, HeapWords a5, HeapWords a4, HeapWords a3, HeapWords a2, HeapWords a1, HeapWords a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> Int Source #

heapWordsUArray :: ( Ix i, IArray a e) => Int -> a i e -> Int Source #

heapWordsUVector :: Unbox e => Int -> Vector e -> Int Source #

heapWordsUnpacked :: HeapWords a => a -> Int Source #

Calculate the number of heap words used by a field unpacked within another constructor.

This function simply subtracts 2 from the heapWords result of its parameter, since in the case of an unpacked field we _do not_ have to use:

a word for the pointer to the inner structure.
a word for the constructor that is being unpacked.

data ClosureTreeOptions Source #

Options which detail how a Closure Tree should be constructed.

Constructors

ClosureTreeOptions
Fields ctoMaxDepth :: ! TreeDepth Construct a closure tree given a maximum depth. ctoCyclicClosures :: ! TraverseCyclicClosures Whether to traverse cyclic closures while constructing a closure tree.

Instances

Instances details

Show ClosureTreeOptions Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Tree Methods showsPrec :: Int -> ClosureTreeOptions -> ShowS Source # show :: ClosureTreeOptions -> String Source # showList :: [ ClosureTreeOptions ] -> ShowS Source #

data TraverseCyclicClosures Source #

Whether to traverse cyclic closures in a Closure Tree .

Constructors

TraverseCyclicClosures	Traverse cyclic closures.
NoTraverseCyclicClosures	Do not traverse cyclic closures.

Instances

Instances details

Show TraverseCyclicClosures Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Tree Methods showsPrec :: Int -> TraverseCyclicClosures -> ShowS Source # show :: TraverseCyclicClosures -> String Source # showList :: [ TraverseCyclicClosures ] -> ShowS Source #

data TreeDepth Source #

The depth of a Tree .

Constructors

TreeDepth ! Int	A specific tree depth bound.
AnyDepth	No tree depth bound.

Instances

Instances details

Show TreeDepth Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Tree Methods showsPrec :: Int -> TreeDepth -> ShowS Source # show :: TreeDepth -> String Source # showList :: [ TreeDepth ] -> ShowS Source #

buildClosureTree :: ClosureTreeOptions -> a -> IO ( Maybe ( Tree Closure )) Source #

Given a Haskell expression, build a Tree which reflects its heap object representation.

buildAndRenderClosureTree :: ClosureTreeOptions -> a -> IO Text Source #

Given a Haskell expression, build a Tree which reflects its heap object representation and render it as Text .

depth :: Tree a -> Int Source #

isZeroOrNegativeTreeDepth :: TreeDepth -> Bool Source #

renderClosure :: Closure -> Text Source #

renderTree :: Tree a -> (a -> Text ) -> Text Source #

data CountFailure Source #

Constructors

WorkListFull
VisitedFull
OutOfMemory
UnsupportedClosure ClosureType

Instances

Instances details

Eq CountFailure Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Size Methods (==) :: CountFailure -> CountFailure -> Bool Source # (/=) :: CountFailure -> CountFailure -> Bool Source #
Show CountFailure Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Size Methods showsPrec :: Int -> CountFailure -> ShowS Source # show :: CountFailure -> String Source # showList :: [ CountFailure ] -> ShowS Source #

data PerformGC Source #

Should we perform a GC call before counting the size?

Constructors

FirstPerformGC

Yes, first perform GC before counting

This should be used for most accurate results. Without calling GC first, the computed size might be larger than expected due to leftover indirections (black holes, selector thunks, etc.)

DontPerformGC

No, do not perform GC before counting

If pinpoint accuracy is not requried, then GC can be skipped, making the call much less expensive.

computeHeapSize :: a -> IO ( Either CountFailure Word64 ) Source #

Compute the size of the given closure

This is a wrapper around computeHeapSize' which sets some defaults for the capacity of worklist and the visited set: it uses a worklist capacity of 10k (which, assuming balanced data structures, should be more than enough), an initial visited set capacity of 250k, and a maximum visited set capacity of 16M. This means that this will use between 2 MB and 128 MB of heaps space.

It also does NOT perform GC before counting, for improved performance. Client code can call performMajorGC manually or use computeHeapSize' .

Should these limits not be sufficient, or conversely, the memory requirements be too large, use computeHeapSize' directly.

computeHeapSize' Source #

Arguments

:: PerformGC	Should we call GC before counting?
-> Word	Capacity of the worklist
-> Word	Initial capacity of the visited set
-> Word	Maximum capacity of the visited set
-> a
-> IO ( Either CountFailure Word64 )

Compute the size of the given closure

The size of the worklist should be set to the maximum expected depth of the closure; the size of the visited set should be set to the maximum /number of nodes/ in the closure.

computeHeapSizeWorkList can be used to estimate the size of the worklist required.

computeHeapSizeWorkList :: a -> Word64 Source #

Upper bound on the required work list size to compute closure size

NOTE: This ignores sharing, and so provides an upper bound only.

The size of a closure with no nested pointers can be computed without any stack space.

When we have a closure with (N + 1) nested pointers

p0 p1 .. pN

We will

Push pN, .., p1, p0 onto the stack
Pop off p0 and count its children
Pop off p1 and count its children
..

until we have processed all children. This means that the stack space required will be the maximum of

[ N + 1 -- For the initial list
, requiredWorkList p0 + (N + 1) - 1
, requiredWorkList p1 + (N + 1) - 2
, ..
, requiredWorkList pN + (N + 1) - (N + 1)
]

For example, for a list, we would get that

requiredWorkList []     == 0
requiredWorkList (x:xs) == max [ 2
                               , requiredWorkList x + 1
                               , requiredWorkList xs
                               ]

which, for a list of Int (which requires only a stack of size 1), equals 2 (unless the list is empty).

Similarly, for binary trees, we get

requiredWorkList Leaf           == 0
requiredWorkList (Branch l x r) == max [ 3
                                       , requiredWorkList l + 2
                                       , requiredWorkList x + 1
                                       , requiredWorkList r
                                       ]

which, for a tree of Int , is bound by (height * 2) + 1 .

isHeadNormalForm :: Closure -> IO Bool Source #

isNormalForm :: a -> IO Bool Source #

The function isNormalForm checks whether its argument is fully evaluated and deeply evaluated.

NOTE: The normal form check can be quite brittle, especially with -O0 . For example, writing something like

let !(Value x) = ... in ....

might translate to

let !.. = ... in ... (case ... of Value x -> x)

which would trivially be False . In general, isNormalForm should probably only be used with -O1 , but even then the answer may still depend on internal decisions made by ghc during compilation.

base16Builder :: ByteString -> Builder Source #

A Builder for a ByteString that performs base 16 encoding

base16F :: Format r ( ByteString -> r) Source #

A Format for a ByteString that performs base 16 encoding

pairF :: ( Buildable a, Buildable b) => Format r ((a, b) -> r) Source #

A Format for a pair of Buildable values (a, b)

pairBuilder :: ( Buildable a, Buildable b) => (a, b) -> Builder Source #

A Builder for a pair of Buildable values (a, b)

listJson :: ( Foldable t, Buildable a) => Format r (t a -> r) Source #

A Format for Foldable containers that outputs a JSON-style list

listJsonIndent :: ( Foldable t, Buildable a) => Word -> Format r (t a -> r) Source #

A Format similar to listJson that prints each value on a new line with indent spaces of indentation

mapJson :: ( IsList t, Item t ~ (k, v), Buildable k, Buildable v) => Format r (t -> r) Source #

A Format for Exts.IsList containers of Buildable key-value pairs that outputs a JSON-style colon-separated map

toAesonError :: Buildable e => Either e a -> Parser a Source #

Convert an Either -encoded error to an aeson parser error

aesonError :: Buildable e => e -> Parser a Source #

Convert a Buildable error into an aeson parser error

toCborError :: Buildable e => Either e a -> Decoder s a Source #

Convert an Either -encoded failure to a cborg decoder failure

cborError :: Buildable e => e -> Decoder s a Source #

Convert a Buildable error into a cborg decoder error

wrapError :: MonadError e' m => Either e a -> (e -> e') -> m a infix 1 Source #

A helper for lifting an Either to a MonadError

By using this function infix we can move the error handling to the end of an expression, hopefully improving readability.

orThrowError :: MonadError e m => Bool -> e -> m () infix 1 Source #

A helper for lifting unless to MonadError

By using this function infix we can move error handling to the end of a Bool expression, hopefully improving readability.

(++) :: [a] -> [a] -> [a] infixr 5 Source #

Append two lists, i.e.,

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

seq :: forall (r :: RuntimeRep ) a (b :: TYPE r). a -> b -> b infixr 0 Source #

The value of seq a b is bottom if a is bottom, and otherwise equal to b . In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b . The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a . If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

filter :: (a -> Bool ) -> [a] -> [a] Source #

$\mathcal{O}(n)$ . filter , applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

filter p xs = [ x | x <- xs, p x]

>>> filter odd [1, 2, 3]
[1,3]

zip :: [a] -> [b] -> [(a, b)] Source #

$\mathcal{O}(\min(m,n))$ . zip takes two lists and returns a list of corresponding pairs.

zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]

If one input list is short, excess elements of the longer list are discarded:

zip [1] ['a', 'b'] = [(1, 'a')]
zip [1, 2] ['a'] = [(1, 'a')]

zip is right-lazy:

zip [] _|_ = []
zip _|_ [] = _|_

zip is capable of list fusion, but it is restricted to its first list argument and its resulting list.

fst :: (a, b) -> a Source #

Extract the first component of a pair.

snd :: (a, b) -> b Source #

Extract the second component of a pair.

otherwise :: Bool Source #

otherwise is defined as the value True . It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

($) :: forall (r :: RuntimeRep ) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 Source #

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x) . However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ( $ 0) xs , or zipWith ( $ ) fs xs .

Note that ( $ ) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

fromIntegral :: ( Integral a, Num b) => a -> b Source #

general coercion from integral types

realToFrac :: ( Real a, Fractional b) => a -> b Source #

general coercion to fractional types

guard :: Alternative f => Bool -> f () Source #

Conditional failure of Alternative computations. Defined by

guard True  = pure ()
guard False = empty

Examples

Expand

Common uses of guard include conditionally signaling an error in an error monad and conditionally rejecting the current choice in an Alternative -based parser.

As an example of signaling an error in the error monad Maybe , consider a safe division function safeDiv x y that returns Nothing when the denominator y is zero and Just (x `div` y) otherwise. For example:

>>> safeDiv 4 0
Nothing
>>> safeDiv 4 2
Just 2

A definition of safeDiv using guards, but not guard :

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0    = Just (x `div` y)
            | otherwise = Nothing

A definition of safeDiv using guard and Monad do -notation:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

join :: Monad m => m (m a) -> m a Source #

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

' join bss ' can be understood as the do expression

do bs <- bss
   bs

Examples

Expand

A common use of join is to run an IO computation returned from an STM transaction, since STM transactions can't perform IO directly. Recall that

atomically :: STM a -> IO a

is used to run STM transactions atomically. So, by specializing the types of atomically and join to

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

we can compose them as

join . atomically :: STM (IO b) -> IO b

to run an STM transaction and the IO action it returns.

class Bounded a where Source #

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

maxBound :: a Source #

Instances

Instances details

Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool Source # maxBound :: Bool Source #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char Source # maxBound :: Char Source #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int Source # maxBound :: Int Source #
Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 Source # maxBound :: Int8 Source #
Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 Source # maxBound :: Int16 Source #
Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 Source # maxBound :: Int32 Source #
Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 Source # maxBound :: Int64 Source #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering Source # maxBound :: Ordering Source #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word Source # maxBound :: Word Source #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 Source # maxBound :: Word8 Source #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 Source # maxBound :: Word16 Source #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 Source # maxBound :: Word32 Source #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 Source # maxBound :: Word64 Source #
Bounded VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecCount Source # maxBound :: VecCount Source #
Bounded VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecElem Source # maxBound :: VecElem Source #
Bounded ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: () Source # maxBound :: () Source #
Bounded CDev
Instance details Defined in System.Posix.Types Methods minBound :: CDev Source # maxBound :: CDev Source #
Bounded CIno
Instance details Defined in System.Posix.Types Methods minBound :: CIno Source # maxBound :: CIno Source #
Bounded CMode
Instance details Defined in System.Posix.Types Methods minBound :: CMode Source # maxBound :: CMode Source #
Bounded COff
Instance details Defined in System.Posix.Types Methods minBound :: COff Source # maxBound :: COff Source #
Bounded CPid
Instance details Defined in System.Posix.Types Methods minBound :: CPid Source # maxBound :: CPid Source #
Bounded CSsize
Instance details Defined in System.Posix.Types Methods minBound :: CSsize Source # maxBound :: CSsize Source #
Bounded CGid
Instance details Defined in System.Posix.Types Methods minBound :: CGid Source # maxBound :: CGid Source #
Bounded CNlink
Instance details Defined in System.Posix.Types Methods minBound :: CNlink Source # maxBound :: CNlink Source #
Bounded CUid
Instance details Defined in System.Posix.Types Methods minBound :: CUid Source # maxBound :: CUid Source #
Bounded CTcflag
Instance details Defined in System.Posix.Types Methods minBound :: CTcflag Source # maxBound :: CTcflag Source #
Bounded CRLim
Instance details Defined in System.Posix.Types Methods minBound :: CRLim Source # maxBound :: CRLim Source #
Bounded CBlkSize
Instance details Defined in System.Posix.Types Methods minBound :: CBlkSize Source # maxBound :: CBlkSize Source #
Bounded CBlkCnt
Instance details Defined in System.Posix.Types Methods minBound :: CBlkCnt Source # maxBound :: CBlkCnt Source #
Bounded CClockId
Instance details Defined in System.Posix.Types Methods minBound :: CClockId Source # maxBound :: CClockId Source #
Bounded CFsBlkCnt
Instance details Defined in System.Posix.Types Methods minBound :: CFsBlkCnt Source # maxBound :: CFsBlkCnt Source #
Bounded CFsFilCnt
Instance details Defined in System.Posix.Types Methods minBound :: CFsFilCnt Source # maxBound :: CFsFilCnt Source #
Bounded CId
Instance details Defined in System.Posix.Types Methods minBound :: CId Source # maxBound :: CId Source #
Bounded CKey
Instance details Defined in System.Posix.Types Methods minBound :: CKey Source # maxBound :: CKey Source #
Bounded CSocklen
Instance details Defined in System.Posix.Types Methods minBound :: CSocklen Source # maxBound :: CSocklen Source #
Bounded CNfds
Instance details Defined in System.Posix.Types Methods minBound :: CNfds Source # maxBound :: CNfds Source #
Bounded Fd
Instance details Defined in System.Posix.Types Methods minBound :: Fd Source # maxBound :: Fd Source #
Bounded All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: All Source # maxBound :: All Source #
Bounded Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Any Source # maxBound :: Any Source #
Bounded Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: Associativity Source # maxBound :: Associativity Source #
Bounded SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceUnpackedness Source # maxBound :: SourceUnpackedness Source #
Bounded SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceStrictness Source # maxBound :: SourceStrictness Source #
Bounded DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: DecidedStrictness Source # maxBound :: DecidedStrictness Source #
Bounded CChar
Instance details Defined in Foreign.C.Types Methods minBound :: CChar Source # maxBound :: CChar Source #
Bounded CSChar
Instance details Defined in Foreign.C.Types Methods minBound :: CSChar Source # maxBound :: CSChar Source #
Bounded CUChar
Instance details Defined in Foreign.C.Types Methods minBound :: CUChar Source # maxBound :: CUChar Source #
Bounded CShort
Instance details Defined in Foreign.C.Types Methods minBound :: CShort Source # maxBound :: CShort Source #
Bounded CUShort
Instance details Defined in Foreign.C.Types Methods minBound :: CUShort Source # maxBound :: CUShort Source #
Bounded CInt
Instance details Defined in Foreign.C.Types Methods minBound :: CInt Source # maxBound :: CInt Source #
Bounded CUInt
Instance details Defined in Foreign.C.Types Methods minBound :: CUInt Source # maxBound :: CUInt Source #
Bounded CLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLong Source # maxBound :: CLong Source #
Bounded CULong
Instance details Defined in Foreign.C.Types Methods minBound :: CULong Source # maxBound :: CULong Source #
Bounded CLLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLLong Source # maxBound :: CLLong Source #
Bounded CULLong
Instance details Defined in Foreign.C.Types Methods minBound :: CULLong Source # maxBound :: CULLong Source #
Bounded CBool
Instance details Defined in Foreign.C.Types Methods minBound :: CBool Source # maxBound :: CBool Source #
Bounded CPtrdiff
Instance details Defined in Foreign.C.Types Methods minBound :: CPtrdiff Source # maxBound :: CPtrdiff Source #
Bounded CSize
Instance details Defined in Foreign.C.Types Methods minBound :: CSize Source # maxBound :: CSize Source #
Bounded CWchar
Instance details Defined in Foreign.C.Types Methods minBound :: CWchar Source # maxBound :: CWchar Source #
Bounded CSigAtomic
Instance details Defined in Foreign.C.Types Methods minBound :: CSigAtomic Source # maxBound :: CSigAtomic Source #
Bounded CIntPtr
Instance details Defined in Foreign.C.Types Methods minBound :: CIntPtr Source # maxBound :: CIntPtr Source #
Bounded CUIntPtr
Instance details Defined in Foreign.C.Types Methods minBound :: CUIntPtr Source # maxBound :: CUIntPtr Source #
Bounded CIntMax
Instance details Defined in Foreign.C.Types Methods minBound :: CIntMax Source # maxBound :: CIntMax Source #
Bounded CUIntMax
Instance details Defined in Foreign.C.Types Methods minBound :: CUIntMax Source # maxBound :: CUIntMax Source #
Bounded WordPtr
Instance details Defined in Foreign.Ptr Methods minBound :: WordPtr Source # maxBound :: WordPtr Source #
Bounded IntPtr
Instance details Defined in Foreign.Ptr Methods minBound :: IntPtr Source # maxBound :: IntPtr Source #
Bounded GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods minBound :: GeneralCategory Source # maxBound :: GeneralCategory Source #
Bounded Int54
Instance details Defined in Text.JSON.Canonical.Types Methods minBound :: Int54 Source # maxBound :: Int54 Source #
Bounded TokenType
Instance details Defined in Codec.CBOR.Decoding Methods minBound :: TokenType Source # maxBound :: TokenType Source #
Bounded Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods minBound :: Extension Source # maxBound :: Extension Source #
Bounded a => Bounded ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods minBound :: Solo a Source # maxBound :: Solo a Source #
Bounded a => Bounded ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Min a Source # maxBound :: Min a Source #
Bounded a => Bounded ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Max a Source # maxBound :: Max a Source #
Bounded a => Bounded ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: First a Source # maxBound :: First a Source #
Bounded a => Bounded ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Last a Source # maxBound :: Last a Source #
Bounded m => Bounded ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m Source # maxBound :: WrappedMonoid m Source #
Bounded a => Bounded ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a Source # maxBound :: Identity a Source #
Bounded a => Bounded ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Dual a Source # maxBound :: Dual a Source #
Bounded a => Bounded ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Sum a Source # maxBound :: Sum a Source #
Bounded a => Bounded ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Product a Source # maxBound :: Product a Source #
Bounded a => Bounded ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods minBound :: Down a Source # maxBound :: Down a Source #
Bounded a => Bounded ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods minBound :: Shown a Source # maxBound :: Shown a Source #
( Bounded a, Bounded b) => Bounded (a, b)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b) Source # maxBound :: (a, b) Source #
Bounded ( Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t Source # maxBound :: Proxy t Source #
( Bounded a, Bounded b) => Bounded ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods minBound :: Pair a b Source # maxBound :: Pair a b Source #
( 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) Source # maxBound :: (a, b, c) Source #
Bounded a => Bounded ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b Source # maxBound :: Const a b Source #
( Applicative f, Bounded a) => Bounded ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods minBound :: Ap f a Source # maxBound :: Ap f a Source #
Coercible a b => Bounded ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods minBound :: Coercion a b Source # maxBound :: Coercion a b Source #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b Source # maxBound :: a :~: b Source #
Bounded b => Bounded ( Tagged s b)
Instance details Defined in Data.Tagged Methods minBound :: Tagged s b Source # maxBound :: Tagged s b Source #
( 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) Source # maxBound :: (a, b, c, d) Source #
a ~~ b => Bounded (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~~: b Source # maxBound :: a :~~: b Source #
( 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) Source # maxBound :: (a, b, c, d, e) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h, i) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h, i, j) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h, i, j, k) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #
( 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) Source # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #

class Enum a where Source #

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

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

pred :: a -> a Source #

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

toEnum :: Int -> a Source #

Convert from an Int .

fromEnum :: a -> Int Source #

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

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

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

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

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 Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool Source # pred :: Bool -> Bool Source # toEnum :: Int -> Bool Source # fromEnum :: Bool -> Int Source # enumFrom :: Bool -> [ Bool ] Source # enumFromThen :: Bool -> Bool -> [ Bool ] Source # enumFromTo :: Bool -> Bool -> [ Bool ] Source # enumFromThenTo :: Bool -> Bool -> Bool -> [ Bool ] Source #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char Source # pred :: Char -> Char Source # toEnum :: Int -> Char Source # fromEnum :: Char -> Int Source # enumFrom :: Char -> [ Char ] Source # enumFromThen :: Char -> Char -> [ Char ] Source # enumFromTo :: Char -> Char -> [ Char ] Source # enumFromThenTo :: Char -> Char -> Char -> [ Char ] Source #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int Source # pred :: Int -> Int Source # toEnum :: Int -> Int Source # fromEnum :: Int -> Int Source # enumFrom :: Int -> [ Int ] Source # enumFromThen :: Int -> Int -> [ Int ] Source # enumFromTo :: Int -> Int -> [ Int ] Source # enumFromThenTo :: Int -> Int -> Int -> [ Int ] Source #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int8 -> Int8 Source # pred :: Int8 -> Int8 Source # toEnum :: Int -> Int8 Source # fromEnum :: Int8 -> Int Source # enumFrom :: Int8 -> [ Int8 ] Source # enumFromThen :: Int8 -> Int8 -> [ Int8 ] Source # enumFromTo :: Int8 -> Int8 -> [ Int8 ] Source # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [ Int8 ] Source #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 Source # pred :: Int16 -> Int16 Source # toEnum :: Int -> Int16 Source # fromEnum :: Int16 -> Int Source # enumFrom :: Int16 -> [ Int16 ] Source # enumFromThen :: Int16 -> Int16 -> [ Int16 ] Source # enumFromTo :: Int16 -> Int16 -> [ Int16 ] Source # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [ Int16 ] Source #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 Source # pred :: Int32 -> Int32 Source # toEnum :: Int -> Int32 Source # fromEnum :: Int32 -> Int Source # enumFrom :: Int32 -> [ Int32 ] Source # enumFromThen :: Int32 -> Int32 -> [ Int32 ] Source # enumFromTo :: Int32 -> Int32 -> [ Int32 ] Source # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [ Int32 ] Source #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 Source # pred :: Int64 -> Int64 Source # toEnum :: Int -> Int64 Source # fromEnum :: Int64 -> Int Source # enumFrom :: Int64 -> [ Int64 ] Source # enumFromThen :: Int64 -> Int64 -> [ Int64 ] Source # enumFromTo :: Int64 -> Int64 -> [ Int64 ] Source # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [ Int64 ] Source #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer Source # pred :: Integer -> Integer Source # toEnum :: Int -> Integer Source # fromEnum :: Integer -> Int Source # enumFrom :: Integer -> [ Integer ] Source # enumFromThen :: Integer -> Integer -> [ Integer ] Source # enumFromTo :: Integer -> Integer -> [ Integer ] Source # enumFromThenTo :: Integer -> Integer -> Integer -> [ Integer ] Source #
Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural Source # pred :: Natural -> Natural Source # toEnum :: Int -> Natural Source # fromEnum :: Natural -> Int Source # enumFrom :: Natural -> [ Natural ] Source # enumFromThen :: Natural -> Natural -> [ Natural ] Source # enumFromTo :: Natural -> Natural -> [ Natural ] Source # enumFromThenTo :: Natural -> Natural -> Natural -> [ Natural ] Source #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering Source # pred :: Ordering -> Ordering Source # toEnum :: Int -> Ordering Source # fromEnum :: Ordering -> Int Source # enumFrom :: Ordering -> [ Ordering ] Source # enumFromThen :: Ordering -> Ordering -> [ Ordering ] Source # enumFromTo :: Ordering -> Ordering -> [ Ordering ] Source # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [ Ordering ] Source #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word Source # pred :: Word -> Word Source # toEnum :: Int -> Word Source # fromEnum :: Word -> Int Source # enumFrom :: Word -> [ Word ] Source # enumFromThen :: Word -> Word -> [ Word ] Source # enumFromTo :: Word -> Word -> [ Word ] Source # enumFromThenTo :: Word -> Word -> Word -> [ Word ] Source #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 Source # pred :: Word8 -> Word8 Source # toEnum :: Int -> Word8 Source # fromEnum :: Word8 -> Int Source # enumFrom :: Word8 -> [ Word8 ] Source # enumFromThen :: Word8 -> Word8 -> [ Word8 ] Source # enumFromTo :: Word8 -> Word8 -> [ Word8 ] Source # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [ Word8 ] Source #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 Source # pred :: Word16 -> Word16 Source # toEnum :: Int -> Word16 Source # fromEnum :: Word16 -> Int Source # enumFrom :: Word16 -> [ Word16 ] Source # enumFromThen :: Word16 -> Word16 -> [ Word16 ] Source # enumFromTo :: Word16 -> Word16 -> [ Word16 ] Source # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [ Word16 ] Source #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 Source # pred :: Word32 -> Word32 Source # toEnum :: Int -> Word32 Source # fromEnum :: Word32 -> Int Source # enumFrom :: Word32 -> [ Word32 ] Source # enumFromThen :: Word32 -> Word32 -> [ Word32 ] Source # enumFromTo :: Word32 -> Word32 -> [ Word32 ] Source # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [ Word32 ] Source #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 Source # pred :: Word64 -> Word64 Source # toEnum :: Int -> Word64 Source # fromEnum :: Word64 -> Int Source # enumFrom :: Word64 -> [ Word64 ] Source # enumFromThen :: Word64 -> Word64 -> [ Word64 ] Source # enumFromTo :: Word64 -> Word64 -> [ Word64 ] Source # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [ Word64 ] Source #
Enum VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecCount -> VecCount Source # pred :: VecCount -> VecCount Source # toEnum :: Int -> VecCount Source # fromEnum :: VecCount -> Int Source # enumFrom :: VecCount -> [ VecCount ] Source # enumFromThen :: VecCount -> VecCount -> [ VecCount ] Source # enumFromTo :: VecCount -> VecCount -> [ VecCount ] Source # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [ VecCount ] Source #
Enum VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecElem -> VecElem Source # pred :: VecElem -> VecElem Source # toEnum :: Int -> VecElem Source # fromEnum :: VecElem -> Int Source # enumFrom :: VecElem -> [ VecElem ] Source # enumFromThen :: VecElem -> VecElem -> [ VecElem ] Source # enumFromTo :: VecElem -> VecElem -> [ VecElem ] Source # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [ VecElem ] Source #
Enum ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: () -> () Source # pred :: () -> () Source # toEnum :: Int -> () Source # fromEnum :: () -> Int Source # enumFrom :: () -> [()] Source # enumFromThen :: () -> () -> [()] Source # enumFromTo :: () -> () -> [()] Source # enumFromThenTo :: () -> () -> () -> [()] Source #
Enum CDev
Instance details Defined in System.Posix.Types Methods succ :: CDev -> CDev Source # pred :: CDev -> CDev Source # toEnum :: Int -> CDev Source # fromEnum :: CDev -> Int Source # enumFrom :: CDev -> [ CDev ] Source # enumFromThen :: CDev -> CDev -> [ CDev ] Source # enumFromTo :: CDev -> CDev -> [ CDev ] Source # enumFromThenTo :: CDev -> CDev -> CDev -> [ CDev ] Source #
Enum CIno
Instance details Defined in System.Posix.Types Methods succ :: CIno -> CIno Source # pred :: CIno -> CIno Source # toEnum :: Int -> CIno Source # fromEnum :: CIno -> Int Source # enumFrom :: CIno -> [ CIno ] Source # enumFromThen :: CIno -> CIno -> [ CIno ] Source # enumFromTo :: CIno -> CIno -> [ CIno ] Source # enumFromThenTo :: CIno -> CIno -> CIno -> [ CIno ] Source #
Enum CMode
Instance details Defined in System.Posix.Types Methods succ :: CMode -> CMode Source # pred :: CMode -> CMode Source # toEnum :: Int -> CMode Source # fromEnum :: CMode -> Int Source # enumFrom :: CMode -> [ CMode ] Source # enumFromThen :: CMode -> CMode -> [ CMode ] Source # enumFromTo :: CMode -> CMode -> [ CMode ] Source # enumFromThenTo :: CMode -> CMode -> CMode -> [ CMode ] Source #
Enum COff
Instance details Defined in System.Posix.Types Methods succ :: COff -> COff Source # pred :: COff -> COff Source # toEnum :: Int -> COff Source # fromEnum :: COff -> Int Source # enumFrom :: COff -> [ COff ] Source # enumFromThen :: COff -> COff -> [ COff ] Source # enumFromTo :: COff -> COff -> [ COff ] Source # enumFromThenTo :: COff -> COff -> COff -> [ COff ] Source #
Enum CPid
Instance details Defined in System.Posix.Types Methods succ :: CPid -> CPid Source # pred :: CPid -> CPid Source # toEnum :: Int -> CPid Source # fromEnum :: CPid -> Int Source # enumFrom :: CPid -> [ CPid ] Source # enumFromThen :: CPid -> CPid -> [ CPid ] Source # enumFromTo :: CPid -> CPid -> [ CPid ] Source # enumFromThenTo :: CPid -> CPid -> CPid -> [ CPid ] Source #
Enum CSsize
Instance details Defined in System.Posix.Types Methods succ :: CSsize -> CSsize Source # pred :: CSsize -> CSsize Source # toEnum :: Int -> CSsize Source # fromEnum :: CSsize -> Int Source # enumFrom :: CSsize -> [ CSsize ] Source # enumFromThen :: CSsize -> CSsize -> [ CSsize ] Source # enumFromTo :: CSsize -> CSsize -> [ CSsize ] Source # enumFromThenTo :: CSsize -> CSsize -> CSsize -> [ CSsize ] Source #
Enum CGid
Instance details Defined in System.Posix.Types Methods succ :: CGid -> CGid Source # pred :: CGid -> CGid Source # toEnum :: Int -> CGid Source # fromEnum :: CGid -> Int Source # enumFrom :: CGid -> [ CGid ] Source # enumFromThen :: CGid -> CGid -> [ CGid ] Source # enumFromTo :: CGid -> CGid -> [ CGid ] Source # enumFromThenTo :: CGid -> CGid -> CGid -> [ CGid ] Source #
Enum CNlink
Instance details Defined in System.Posix.Types Methods succ :: CNlink -> CNlink Source # pred :: CNlink -> CNlink Source # toEnum :: Int -> CNlink Source # fromEnum :: CNlink -> Int Source # enumFrom :: CNlink -> [ CNlink ] Source # enumFromThen :: CNlink -> CNlink -> [ CNlink ] Source # enumFromTo :: CNlink -> CNlink -> [ CNlink ] Source # enumFromThenTo :: CNlink -> CNlink -> CNlink -> [ CNlink ] Source #
Enum CUid
Instance details Defined in System.Posix.Types Methods succ :: CUid -> CUid Source # pred :: CUid -> CUid Source # toEnum :: Int -> CUid Source # fromEnum :: CUid -> Int Source # enumFrom :: CUid -> [ CUid ] Source # enumFromThen :: CUid -> CUid -> [ CUid ] Source # enumFromTo :: CUid -> CUid -> [ CUid ] Source # enumFromThenTo :: CUid -> CUid -> CUid -> [ CUid ] Source #
Enum CCc
Instance details Defined in System.Posix.Types Methods succ :: CCc -> CCc Source # pred :: CCc -> CCc Source # toEnum :: Int -> CCc Source # fromEnum :: CCc -> Int Source # enumFrom :: CCc -> [ CCc ] Source # enumFromThen :: CCc -> CCc -> [ CCc ] Source # enumFromTo :: CCc -> CCc -> [ CCc ] Source # enumFromThenTo :: CCc -> CCc -> CCc -> [ CCc ] Source #
Enum CSpeed
Instance details Defined in System.Posix.Types Methods succ :: CSpeed -> CSpeed Source # pred :: CSpeed -> CSpeed Source # toEnum :: Int -> CSpeed Source # fromEnum :: CSpeed -> Int Source # enumFrom :: CSpeed -> [ CSpeed ] Source # enumFromThen :: CSpeed -> CSpeed -> [ CSpeed ] Source # enumFromTo :: CSpeed -> CSpeed -> [ CSpeed ] Source # enumFromThenTo :: CSpeed -> CSpeed -> CSpeed -> [ CSpeed ] Source #
Enum CTcflag
Instance details Defined in System.Posix.Types Methods succ :: CTcflag -> CTcflag Source # pred :: CTcflag -> CTcflag Source # toEnum :: Int -> CTcflag Source # fromEnum :: CTcflag -> Int Source # enumFrom :: CTcflag -> [ CTcflag ] Source # enumFromThen :: CTcflag -> CTcflag -> [ CTcflag ] Source # enumFromTo :: CTcflag -> CTcflag -> [ CTcflag ] Source # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [ CTcflag ] Source #
Enum CRLim
Instance details Defined in System.Posix.Types Methods succ :: CRLim -> CRLim Source # pred :: CRLim -> CRLim Source # toEnum :: Int -> CRLim Source # fromEnum :: CRLim -> Int Source # enumFrom :: CRLim -> [ CRLim ] Source # enumFromThen :: CRLim -> CRLim -> [ CRLim ] Source # enumFromTo :: CRLim -> CRLim -> [ CRLim ] Source # enumFromThenTo :: CRLim -> CRLim -> CRLim -> [ CRLim ] Source #
Enum CBlkSize
Instance details Defined in System.Posix.Types Methods succ :: CBlkSize -> CBlkSize Source # pred :: CBlkSize -> CBlkSize Source # toEnum :: Int -> CBlkSize Source # fromEnum :: CBlkSize -> Int Source # enumFrom :: CBlkSize -> [ CBlkSize ] Source # enumFromThen :: CBlkSize -> CBlkSize -> [ CBlkSize ] Source # enumFromTo :: CBlkSize -> CBlkSize -> [ CBlkSize ] Source # enumFromThenTo :: CBlkSize -> CBlkSize -> CBlkSize -> [ CBlkSize ] Source #
Enum CBlkCnt
Instance details Defined in System.Posix.Types Methods succ :: CBlkCnt -> CBlkCnt Source # pred :: CBlkCnt -> CBlkCnt Source # toEnum :: Int -> CBlkCnt Source # fromEnum :: CBlkCnt -> Int Source # enumFrom :: CBlkCnt -> [ CBlkCnt ] Source # enumFromThen :: CBlkCnt -> CBlkCnt -> [ CBlkCnt ] Source # enumFromTo :: CBlkCnt -> CBlkCnt -> [ CBlkCnt ] Source # enumFromThenTo :: CBlkCnt -> CBlkCnt -> CBlkCnt -> [ CBlkCnt ] Source #
Enum CClockId
Instance details Defined in System.Posix.Types Methods succ :: CClockId -> CClockId Source # pred :: CClockId -> CClockId Source # toEnum :: Int -> CClockId Source # fromEnum :: CClockId -> Int Source # enumFrom :: CClockId -> [ CClockId ] Source # enumFromThen :: CClockId -> CClockId -> [ CClockId ] Source # enumFromTo :: CClockId -> CClockId -> [ CClockId ] Source # enumFromThenTo :: CClockId -> CClockId -> CClockId -> [ CClockId ] Source #
Enum CFsBlkCnt
Instance details Defined in System.Posix.Types Methods succ :: CFsBlkCnt -> CFsBlkCnt Source # pred :: CFsBlkCnt -> CFsBlkCnt Source # toEnum :: Int -> CFsBlkCnt Source # fromEnum :: CFsBlkCnt -> Int Source # enumFrom :: CFsBlkCnt -> [ CFsBlkCnt ] Source # enumFromThen :: CFsBlkCnt -> CFsBlkCnt -> [ CFsBlkCnt ] Source # enumFromTo :: CFsBlkCnt -> CFsBlkCnt -> [ CFsBlkCnt ] Source # enumFromThenTo :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt -> [ CFsBlkCnt ] Source #
Enum CFsFilCnt
Instance details Defined in System.Posix.Types Methods succ :: CFsFilCnt -> CFsFilCnt Source # pred :: CFsFilCnt -> CFsFilCnt Source # toEnum :: Int -> CFsFilCnt Source # fromEnum :: CFsFilCnt -> Int Source # enumFrom :: CFsFilCnt -> [ CFsFilCnt ] Source # enumFromThen :: CFsFilCnt -> CFsFilCnt -> [ CFsFilCnt ] Source # enumFromTo :: CFsFilCnt -> CFsFilCnt -> [ CFsFilCnt ] Source # enumFromThenTo :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt -> [ CFsFilCnt ] Source #
Enum CId
Instance details Defined in System.Posix.Types Methods succ :: CId -> CId Source # pred :: CId -> CId Source # toEnum :: Int -> CId Source # fromEnum :: CId -> Int Source # enumFrom :: CId -> [ CId ] Source # enumFromThen :: CId -> CId -> [ CId ] Source # enumFromTo :: CId -> CId -> [ CId ] Source # enumFromThenTo :: CId -> CId -> CId -> [ CId ] Source #
Enum CKey
Instance details Defined in System.Posix.Types Methods succ :: CKey -> CKey Source # pred :: CKey -> CKey Source # toEnum :: Int -> CKey Source # fromEnum :: CKey -> Int Source # enumFrom :: CKey -> [ CKey ] Source # enumFromThen :: CKey -> CKey -> [ CKey ] Source # enumFromTo :: CKey -> CKey -> [ CKey ] Source # enumFromThenTo :: CKey -> CKey -> CKey -> [ CKey ] Source #
Enum CSocklen
Instance details Defined in System.Posix.Types Methods succ :: CSocklen -> CSocklen Source # pred :: CSocklen -> CSocklen Source # toEnum :: Int -> CSocklen Source # fromEnum :: CSocklen -> Int Source # enumFrom :: CSocklen -> [ CSocklen ] Source # enumFromThen :: CSocklen -> CSocklen -> [ CSocklen ] Source # enumFromTo :: CSocklen -> CSocklen -> [ CSocklen ] Source # enumFromThenTo :: CSocklen -> CSocklen -> CSocklen -> [ CSocklen ] Source #
Enum CNfds
Instance details Defined in System.Posix.Types Methods succ :: CNfds -> CNfds Source # pred :: CNfds -> CNfds Source # toEnum :: Int -> CNfds Source # fromEnum :: CNfds -> Int Source # enumFrom :: CNfds -> [ CNfds ] Source # enumFromThen :: CNfds -> CNfds -> [ CNfds ] Source # enumFromTo :: CNfds -> CNfds -> [ CNfds ] Source # enumFromThenTo :: CNfds -> CNfds -> CNfds -> [ CNfds ] Source #
Enum Fd
Instance details Defined in System.Posix.Types Methods succ :: Fd -> Fd Source # pred :: Fd -> Fd Source # toEnum :: Int -> Fd Source # fromEnum :: Fd -> Int Source # enumFrom :: Fd -> [ Fd ] Source # enumFromThen :: Fd -> Fd -> [ Fd ] Source # enumFromTo :: Fd -> Fd -> [ Fd ] Source # enumFromThenTo :: Fd -> Fd -> Fd -> [ Fd ] Source #
Enum Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity Source # pred :: Associativity -> Associativity Source # toEnum :: Int -> Associativity Source # fromEnum :: Associativity -> Int Source # enumFrom :: Associativity -> [ Associativity ] Source # enumFromThen :: Associativity -> Associativity -> [ Associativity ] Source # enumFromTo :: Associativity -> Associativity -> [ Associativity ] Source # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [ Associativity ] Source #
Enum SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness Source # pred :: SourceUnpackedness -> SourceUnpackedness Source # toEnum :: Int -> SourceUnpackedness Source # fromEnum :: SourceUnpackedness -> Int Source # enumFrom :: SourceUnpackedness -> [ SourceUnpackedness ] Source # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [ SourceUnpackedness ] Source # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [ SourceUnpackedness ] Source # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [ SourceUnpackedness ] Source #
Enum SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness Source # pred :: SourceStrictness -> SourceStrictness Source # toEnum :: Int -> SourceStrictness Source # fromEnum :: SourceStrictness -> Int Source # enumFrom :: SourceStrictness -> [ SourceStrictness ] Source # enumFromThen :: SourceStrictness -> SourceStrictness -> [ SourceStrictness ] Source # enumFromTo :: SourceStrictness -> SourceStrictness -> [ SourceStrictness ] Source # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [ SourceStrictness ] Source #
Enum DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness Source # pred :: DecidedStrictness -> DecidedStrictness Source # toEnum :: Int -> DecidedStrictness Source # fromEnum :: DecidedStrictness -> Int Source # enumFrom :: DecidedStrictness -> [ DecidedStrictness ] Source # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [ DecidedStrictness ] Source # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [ DecidedStrictness ] Source # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [ DecidedStrictness ] Source #
Enum CChar
Instance details Defined in Foreign.C.Types Methods succ :: CChar -> CChar Source # pred :: CChar -> CChar Source # toEnum :: Int -> CChar Source # fromEnum :: CChar -> Int Source # enumFrom :: CChar -> [ CChar ] Source # enumFromThen :: CChar -> CChar -> [ CChar ] Source # enumFromTo :: CChar -> CChar -> [ CChar ] Source # enumFromThenTo :: CChar -> CChar -> CChar -> [ CChar ] Source #
Enum CSChar
Instance details Defined in Foreign.C.Types Methods succ :: CSChar -> CSChar Source # pred :: CSChar -> CSChar Source # toEnum :: Int -> CSChar Source # fromEnum :: CSChar -> Int Source # enumFrom :: CSChar -> [ CSChar ] Source # enumFromThen :: CSChar -> CSChar -> [ CSChar ] Source # enumFromTo :: CSChar -> CSChar -> [ CSChar ] Source # enumFromThenTo :: CSChar -> CSChar -> CSChar -> [ CSChar ] Source #
Enum CUChar
Instance details Defined in Foreign.C.Types Methods succ :: CUChar -> CUChar Source # pred :: CUChar -> CUChar Source # toEnum :: Int -> CUChar Source # fromEnum :: CUChar -> Int Source # enumFrom :: CUChar -> [ CUChar ] Source # enumFromThen :: CUChar -> CUChar -> [ CUChar ] Source # enumFromTo :: CUChar -> CUChar -> [ CUChar ] Source # enumFromThenTo :: CUChar -> CUChar -> CUChar -> [ CUChar ] Source #
Enum CShort
Instance details Defined in Foreign.C.Types Methods succ :: CShort -> CShort Source # pred :: CShort -> CShort Source # toEnum :: Int -> CShort Source # fromEnum :: CShort -> Int Source # enumFrom :: CShort -> [ CShort ] Source # enumFromThen :: CShort -> CShort -> [ CShort ] Source # enumFromTo :: CShort -> CShort -> [ CShort ] Source # enumFromThenTo :: CShort -> CShort -> CShort -> [ CShort ] Source #
Enum CUShort
Instance details Defined in Foreign.C.Types Methods succ :: CUShort -> CUShort Source # pred :: CUShort -> CUShort Source # toEnum :: Int -> CUShort Source # fromEnum :: CUShort -> Int Source # enumFrom :: CUShort -> [ CUShort ] Source # enumFromThen :: CUShort -> CUShort -> [ CUShort ] Source # enumFromTo :: CUShort -> CUShort -> [ CUShort ] Source # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [ CUShort ] Source #
Enum CInt
Instance details Defined in Foreign.C.Types Methods succ :: CInt -> CInt Source # pred :: CInt -> CInt Source # toEnum :: Int -> CInt Source # fromEnum :: CInt -> Int Source # enumFrom :: CInt -> [ CInt ] Source # enumFromThen :: CInt -> CInt -> [ CInt ] Source # enumFromTo :: CInt -> CInt -> [ CInt ] Source # enumFromThenTo :: CInt -> CInt -> CInt -> [ CInt ] Source #
Enum CUInt
Instance details Defined in Foreign.C.Types Methods succ :: CUInt -> CUInt Source # pred :: CUInt -> CUInt Source # toEnum :: Int -> CUInt Source # fromEnum :: CUInt -> Int Source # enumFrom :: CUInt -> [ CUInt ] Source # enumFromThen :: CUInt -> CUInt -> [ CUInt ] Source # enumFromTo :: CUInt -> CUInt -> [ CUInt ] Source # enumFromThenTo :: CUInt -> CUInt -> CUInt -> [ CUInt ] Source #
Enum CLong
Instance details Defined in Foreign.C.Types Methods succ :: CLong -> CLong Source # pred :: CLong -> CLong Source # toEnum :: Int -> CLong Source # fromEnum :: CLong -> Int Source # enumFrom :: CLong -> [ CLong ] Source # enumFromThen :: CLong -> CLong -> [ CLong ] Source # enumFromTo :: CLong -> CLong -> [ CLong ] Source # enumFromThenTo :: CLong -> CLong -> CLong -> [ CLong ] Source #
Enum CULong
Instance details Defined in Foreign.C.Types Methods succ :: CULong -> CULong Source # pred :: CULong -> CULong Source # toEnum :: Int -> CULong Source # fromEnum :: CULong -> Int Source # enumFrom :: CULong -> [ CULong ] Source # enumFromThen :: CULong -> CULong -> [ CULong ] Source # enumFromTo :: CULong -> CULong -> [ CULong ] Source # enumFromThenTo :: CULong -> CULong -> CULong -> [ CULong ] Source #
Enum CLLong
Instance details Defined in Foreign.C.Types Methods succ :: CLLong -> CLLong Source # pred :: CLLong -> CLLong Source # toEnum :: Int -> CLLong Source # fromEnum :: CLLong -> Int Source # enumFrom :: CLLong -> [ CLLong ] Source # enumFromThen :: CLLong -> CLLong -> [ CLLong ] Source # enumFromTo :: CLLong -> CLLong -> [ CLLong ] Source # enumFromThenTo :: CLLong -> CLLong -> CLLong -> [ CLLong ] Source #
Enum CULLong
Instance details Defined in Foreign.C.Types Methods succ :: CULLong -> CULLong Source # pred :: CULLong -> CULLong Source # toEnum :: Int -> CULLong Source # fromEnum :: CULLong -> Int Source # enumFrom :: CULLong -> [ CULLong ] Source # enumFromThen :: CULLong -> CULLong -> [ CULLong ] Source # enumFromTo :: CULLong -> CULLong -> [ CULLong ] Source # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [ CULLong ] Source #
Enum CBool
Instance details Defined in Foreign.C.Types Methods succ :: CBool -> CBool Source # pred :: CBool -> CBool Source # toEnum :: Int -> CBool Source # fromEnum :: CBool -> Int Source # enumFrom :: CBool -> [ CBool ] Source # enumFromThen :: CBool -> CBool -> [ CBool ] Source # enumFromTo :: CBool -> CBool -> [ CBool ] Source # enumFromThenTo :: CBool -> CBool -> CBool -> [ CBool ] Source #
Enum CFloat
Instance details Defined in Foreign.C.Types Methods succ :: CFloat -> CFloat Source # pred :: CFloat -> CFloat Source # toEnum :: Int -> CFloat Source # fromEnum :: CFloat -> Int Source # enumFrom :: CFloat -> [ CFloat ] Source # enumFromThen :: CFloat -> CFloat -> [ CFloat ] Source # enumFromTo :: CFloat -> CFloat -> [ CFloat ] Source # enumFromThenTo :: CFloat -> CFloat -> CFloat -> [ CFloat ] Source #
Enum CDouble
Instance details Defined in Foreign.C.Types Methods succ :: CDouble -> CDouble Source # pred :: CDouble -> CDouble Source # toEnum :: Int -> CDouble Source # fromEnum :: CDouble -> Int Source # enumFrom :: CDouble -> [ CDouble ] Source # enumFromThen :: CDouble -> CDouble -> [ CDouble ] Source # enumFromTo :: CDouble -> CDouble -> [ CDouble ] Source # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [ CDouble ] Source #
Enum CPtrdiff
Instance details Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff Source # pred :: CPtrdiff -> CPtrdiff Source # toEnum :: Int -> CPtrdiff Source # fromEnum :: CPtrdiff -> Int Source # enumFrom :: CPtrdiff -> [ CPtrdiff ] Source # enumFromThen :: CPtrdiff -> CPtrdiff -> [ CPtrdiff ] Source # enumFromTo :: CPtrdiff -> CPtrdiff -> [ CPtrdiff ] Source # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [ CPtrdiff ] Source #
Enum CSize
Instance details Defined in Foreign.C.Types Methods succ :: CSize -> CSize Source # pred :: CSize -> CSize Source # toEnum :: Int -> CSize Source # fromEnum :: CSize -> Int Source # enumFrom :: CSize -> [ CSize ] Source # enumFromThen :: CSize -> CSize -> [ CSize ] Source # enumFromTo :: CSize -> CSize -> [ CSize ] Source # enumFromThenTo :: CSize -> CSize -> CSize -> [ CSize ] Source #
Enum CWchar
Instance details Defined in Foreign.C.Types Methods succ :: CWchar -> CWchar Source # pred :: CWchar -> CWchar Source # toEnum :: Int -> CWchar Source # fromEnum :: CWchar -> Int Source # enumFrom :: CWchar -> [ CWchar ] Source # enumFromThen :: CWchar -> CWchar -> [ CWchar ] Source # enumFromTo :: CWchar -> CWchar -> [ CWchar ] Source # enumFromThenTo :: CWchar -> CWchar -> CWchar -> [ CWchar ] Source #
Enum CSigAtomic
Instance details Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic Source # pred :: CSigAtomic -> CSigAtomic Source # toEnum :: Int -> CSigAtomic Source # fromEnum :: CSigAtomic -> Int Source # enumFrom :: CSigAtomic -> [ CSigAtomic ] Source # enumFromThen :: CSigAtomic -> CSigAtomic -> [ CSigAtomic ] Source # enumFromTo :: CSigAtomic -> CSigAtomic -> [ CSigAtomic ] Source # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [ CSigAtomic ] Source #
Enum CClock
Instance details Defined in Foreign.C.Types Methods succ :: CClock -> CClock Source # pred :: CClock -> CClock Source # toEnum :: Int -> CClock Source # fromEnum :: CClock -> Int Source # enumFrom :: CClock -> [ CClock ] Source # enumFromThen :: CClock -> CClock -> [ CClock ] Source # enumFromTo :: CClock -> CClock -> [ CClock ] Source # enumFromThenTo :: CClock -> CClock -> CClock -> [ CClock ] Source #
Enum CTime
Instance details Defined in Foreign.C.Types Methods succ :: CTime -> CTime Source # pred :: CTime -> CTime Source # toEnum :: Int -> CTime Source # fromEnum :: CTime -> Int Source # enumFrom :: CTime -> [ CTime ] Source # enumFromThen :: CTime -> CTime -> [ CTime ] Source # enumFromTo :: CTime -> CTime -> [ CTime ] Source # enumFromThenTo :: CTime -> CTime -> CTime -> [ CTime ] Source #
Enum CUSeconds
Instance details Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds Source # pred :: CUSeconds -> CUSeconds Source # toEnum :: Int -> CUSeconds Source # fromEnum :: CUSeconds -> Int Source # enumFrom :: CUSeconds -> [ CUSeconds ] Source # enumFromThen :: CUSeconds -> CUSeconds -> [ CUSeconds ] Source # enumFromTo :: CUSeconds -> CUSeconds -> [ CUSeconds ] Source # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [ CUSeconds ] Source #
Enum CSUSeconds
Instance details Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds Source # pred :: CSUSeconds -> CSUSeconds Source # toEnum :: Int -> CSUSeconds Source # fromEnum :: CSUSeconds -> Int Source # enumFrom :: CSUSeconds -> [ CSUSeconds ] Source # enumFromThen :: CSUSeconds -> CSUSeconds -> [ CSUSeconds ] Source # enumFromTo :: CSUSeconds -> CSUSeconds -> [ CSUSeconds ] Source # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [ CSUSeconds ] Source #
Enum CIntPtr
Instance details Defined in Foreign.C.Types Methods succ :: CIntPtr -> CIntPtr Source # pred :: CIntPtr -> CIntPtr Source # toEnum :: Int -> CIntPtr Source # fromEnum :: CIntPtr -> Int Source # enumFrom :: CIntPtr -> [ CIntPtr ] Source # enumFromThen :: CIntPtr -> CIntPtr -> [ CIntPtr ] Source # enumFromTo :: CIntPtr -> CIntPtr -> [ CIntPtr ] Source # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [ CIntPtr ] Source #
Enum CUIntPtr
Instance details Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr Source # pred :: CUIntPtr -> CUIntPtr Source # toEnum :: Int -> CUIntPtr Source # fromEnum :: CUIntPtr -> Int Source # enumFrom :: CUIntPtr -> [ CUIntPtr ] Source # enumFromThen :: CUIntPtr -> CUIntPtr -> [ CUIntPtr ] Source # enumFromTo :: CUIntPtr -> CUIntPtr -> [ CUIntPtr ] Source # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [ CUIntPtr ] Source #
Enum CIntMax
Instance details Defined in Foreign.C.Types Methods succ :: CIntMax -> CIntMax Source # pred :: CIntMax -> CIntMax Source # toEnum :: Int -> CIntMax Source # fromEnum :: CIntMax -> Int Source # enumFrom :: CIntMax -> [ CIntMax ] Source # enumFromThen :: CIntMax -> CIntMax -> [ CIntMax ] Source # enumFromTo :: CIntMax -> CIntMax -> [ CIntMax ] Source # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [ CIntMax ] Source #
Enum CUIntMax
Instance details Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax Source # pred :: CUIntMax -> CUIntMax Source # toEnum :: Int -> CUIntMax Source # fromEnum :: CUIntMax -> Int Source # enumFrom :: CUIntMax -> [ CUIntMax ] Source # enumFromThen :: CUIntMax -> CUIntMax -> [ CUIntMax ] Source # enumFromTo :: CUIntMax -> CUIntMax -> [ CUIntMax ] Source # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [ CUIntMax ] Source #
Enum WordPtr
Instance details Defined in Foreign.Ptr Methods succ :: WordPtr -> WordPtr Source # pred :: WordPtr -> WordPtr Source # toEnum :: Int -> WordPtr Source # fromEnum :: WordPtr -> Int Source # enumFrom :: WordPtr -> [ WordPtr ] Source # enumFromThen :: WordPtr -> WordPtr -> [ WordPtr ] Source # enumFromTo :: WordPtr -> WordPtr -> [ WordPtr ] Source # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [ WordPtr ] Source #
Enum IntPtr
Instance details Defined in Foreign.Ptr Methods succ :: IntPtr -> IntPtr Source # pred :: IntPtr -> IntPtr Source # toEnum :: Int -> IntPtr Source # fromEnum :: IntPtr -> Int Source # enumFrom :: IntPtr -> [ IntPtr ] Source # enumFromThen :: IntPtr -> IntPtr -> [ IntPtr ] Source # enumFromTo :: IntPtr -> IntPtr -> [ IntPtr ] Source # enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [ IntPtr ] Source #
Enum IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods succ :: IOMode -> IOMode Source # pred :: IOMode -> IOMode Source # toEnum :: Int -> IOMode Source # fromEnum :: IOMode -> Int Source # enumFrom :: IOMode -> [ IOMode ] Source # enumFromThen :: IOMode -> IOMode -> [ IOMode ] Source # enumFromTo :: IOMode -> IOMode -> [ IOMode ] Source # enumFromThenTo :: IOMode -> IOMode -> IOMode -> [ IOMode ] Source #
Enum GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods succ :: GeneralCategory -> GeneralCategory Source # pred :: GeneralCategory -> GeneralCategory Source # toEnum :: Int -> GeneralCategory Source # fromEnum :: GeneralCategory -> Int Source # enumFrom :: GeneralCategory -> [ GeneralCategory ] Source # enumFromThen :: GeneralCategory -> GeneralCategory -> [ GeneralCategory ] Source # enumFromTo :: GeneralCategory -> GeneralCategory -> [ GeneralCategory ] Source # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [ GeneralCategory ] Source #
Enum Int54
Instance details Defined in Text.JSON.Canonical.Types Methods succ :: Int54 -> Int54 Source # pred :: Int54 -> Int54 Source # toEnum :: Int -> Int54 Source # fromEnum :: Int54 -> Int Source # enumFrom :: Int54 -> [ Int54 ] Source # enumFromThen :: Int54 -> Int54 -> [ Int54 ] Source # enumFromTo :: Int54 -> Int54 -> [ Int54 ] Source # enumFromThenTo :: Int54 -> Int54 -> Int54 -> [ Int54 ] Source #
Enum TokenType
Instance details Defined in Codec.CBOR.Decoding Methods succ :: TokenType -> TokenType Source # pred :: TokenType -> TokenType Source # toEnum :: Int -> TokenType Source # fromEnum :: TokenType -> Int Source # enumFrom :: TokenType -> [ TokenType ] Source # enumFromThen :: TokenType -> TokenType -> [ TokenType ] Source # enumFromTo :: TokenType -> TokenType -> [ TokenType ] Source # enumFromThenTo :: TokenType -> TokenType -> TokenType -> [ TokenType ] Source #
Enum DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods succ :: DiffTime -> DiffTime Source # pred :: DiffTime -> DiffTime Source # toEnum :: Int -> DiffTime Source # fromEnum :: DiffTime -> Int Source # enumFrom :: DiffTime -> [ DiffTime ] Source # enumFromThen :: DiffTime -> DiffTime -> [ DiffTime ] Source # enumFromTo :: DiffTime -> DiffTime -> [ DiffTime ] Source # enumFromThenTo :: DiffTime -> DiffTime -> DiffTime -> [ DiffTime ] Source #
Enum NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods succ :: NominalDiffTime -> NominalDiffTime Source # pred :: NominalDiffTime -> NominalDiffTime Source # toEnum :: Int -> NominalDiffTime Source # fromEnum :: NominalDiffTime -> Int Source # enumFrom :: NominalDiffTime -> [ NominalDiffTime ] Source # enumFromThen :: NominalDiffTime -> NominalDiffTime -> [ NominalDiffTime ] Source # enumFromTo :: NominalDiffTime -> NominalDiffTime -> [ NominalDiffTime ] Source # enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [ NominalDiffTime ] Source #
Enum Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension Source # pred :: Extension -> Extension Source # toEnum :: Int -> Extension Source # fromEnum :: Extension -> Int Source # enumFrom :: Extension -> [ Extension ] Source # enumFromThen :: Extension -> Extension -> [ Extension ] Source # enumFromTo :: Extension -> Extension -> [ Extension ] Source # enumFromThenTo :: Extension -> Extension -> Extension -> [ Extension ] Source #
Enum ClosureType
Instance details Defined in GHC.Exts.Heap.ClosureTypes Methods succ :: ClosureType -> ClosureType Source # pred :: ClosureType -> ClosureType Source # toEnum :: Int -> ClosureType Source # fromEnum :: ClosureType -> Int Source # enumFrom :: ClosureType -> [ ClosureType ] Source # enumFromThen :: ClosureType -> ClosureType -> [ ClosureType ] Source # enumFromTo :: ClosureType -> ClosureType -> [ ClosureType ] Source # enumFromThenTo :: ClosureType -> ClosureType -> ClosureType -> [ ClosureType ] Source #
Enum Day
Instance details Defined in Data.Time.Calendar.Days Methods succ :: Day -> Day Source # pred :: Day -> Day Source # toEnum :: Int -> Day Source # fromEnum :: Day -> Int Source # enumFrom :: Day -> [ Day ] Source # enumFromThen :: Day -> Day -> [ Day ] Source # enumFromTo :: Day -> Day -> [ Day ] Source # enumFromThenTo :: Day -> Day -> Day -> [ Day ] Source #
Integral a => Enum ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods succ :: Ratio a -> Ratio a Source # pred :: Ratio a -> Ratio a Source # toEnum :: Int -> Ratio a Source # fromEnum :: Ratio a -> Int Source # enumFrom :: Ratio a -> [ Ratio a] Source # enumFromThen :: Ratio a -> Ratio a -> [ Ratio a] Source # enumFromTo :: Ratio a -> Ratio a -> [ Ratio a] Source # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [ Ratio a] Source #
Enum a => Enum ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods succ :: Solo a -> Solo a Source # pred :: Solo a -> Solo a Source # toEnum :: Int -> Solo a Source # fromEnum :: Solo a -> Int Source # enumFrom :: Solo a -> [ Solo a] Source # enumFromThen :: Solo a -> Solo a -> [ Solo a] Source # enumFromTo :: Solo a -> Solo a -> [ Solo a] Source # enumFromThenTo :: Solo a -> Solo a -> Solo a -> [ Solo a] Source #
Enum a => Enum ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Min a -> Min a Source # pred :: Min a -> Min a Source # toEnum :: Int -> Min a Source # fromEnum :: Min a -> Int Source # enumFrom :: Min a -> [ Min a] Source # enumFromThen :: Min a -> Min a -> [ Min a] Source # enumFromTo :: Min a -> Min a -> [ Min a] Source # enumFromThenTo :: Min a -> Min a -> Min a -> [ Min a] Source #
Enum a => Enum ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Max a -> Max a Source # pred :: Max a -> Max a Source # toEnum :: Int -> Max a Source # fromEnum :: Max a -> Int Source # enumFrom :: Max a -> [ Max a] Source # enumFromThen :: Max a -> Max a -> [ Max a] Source # enumFromTo :: Max a -> Max a -> [ Max a] Source # enumFromThenTo :: Max a -> Max a -> Max a -> [ Max a] Source #
Enum a => Enum ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: First a -> First a Source # pred :: First a -> First a Source # toEnum :: Int -> First a Source # fromEnum :: First a -> Int Source # enumFrom :: First a -> [ First a] Source # enumFromThen :: First a -> First a -> [ First a] Source # enumFromTo :: First a -> First a -> [ First a] Source # enumFromThenTo :: First a -> First a -> First a -> [ First a] Source #
Enum a => Enum ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Last a -> Last a Source # pred :: Last a -> Last a Source # toEnum :: Int -> Last a Source # fromEnum :: Last a -> Int Source # enumFrom :: Last a -> [ Last a] Source # enumFromThen :: Last a -> Last a -> [ Last a] Source # enumFromTo :: Last a -> Last a -> [ Last a] Source # enumFromThenTo :: Last a -> Last a -> Last a -> [ Last a] Source #
Enum a => Enum ( WrappedMonoid a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a Source # pred :: WrappedMonoid a -> WrappedMonoid a Source # toEnum :: Int -> WrappedMonoid a Source # fromEnum :: WrappedMonoid a -> Int Source # enumFrom :: WrappedMonoid a -> [ WrappedMonoid a] Source # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [ WrappedMonoid a] Source # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [ WrappedMonoid a] Source # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [ WrappedMonoid a] Source #
Enum a => Enum ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a Source # pred :: Identity a -> Identity a Source # toEnum :: Int -> Identity a Source # fromEnum :: Identity a -> Int Source # enumFrom :: Identity a -> [ Identity a] Source # enumFromThen :: Identity a -> Identity a -> [ Identity a] Source # enumFromTo :: Identity a -> Identity a -> [ Identity a] Source # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [ Identity a] Source #
Enum a => Enum ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods succ :: Down a -> Down a Source # pred :: Down a -> Down a Source # toEnum :: Int -> Down a Source # fromEnum :: Down a -> Int Source # enumFrom :: Down a -> [ Down a] Source # enumFromThen :: Down a -> Down a -> [ Down a] Source # enumFromTo :: Down a -> Down a -> [ Down a] Source # enumFromThenTo :: Down a -> Down a -> Down a -> [ Down a] Source #
Enum a => Enum ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods succ :: Hex a -> Hex a Source # pred :: Hex a -> Hex a Source # toEnum :: Int -> Hex a Source # fromEnum :: Hex a -> Int Source # enumFrom :: Hex a -> [ Hex a] Source # enumFromThen :: Hex a -> Hex a -> [ Hex a] Source # enumFromTo :: Hex a -> Hex a -> [ Hex a] Source # enumFromThenTo :: Hex a -> Hex a -> Hex a -> [ Hex a] Source #
Enum a => Enum ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods succ :: Shown a -> Shown a Source # pred :: Shown a -> Shown a Source # toEnum :: Int -> Shown a Source # fromEnum :: Shown a -> Int Source # enumFrom :: Shown a -> [ Shown a] Source # enumFromThen :: Shown a -> Shown a -> [ Shown a] Source # enumFromTo :: Shown a -> Shown a -> [ Shown a] Source # enumFromThenTo :: Shown a -> Shown a -> Shown a -> [ Shown a] Source #
Enum ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods succ :: Fixed a -> Fixed a Source # pred :: Fixed a -> Fixed a Source # toEnum :: Int -> Fixed a Source # fromEnum :: Fixed a -> Int Source # enumFrom :: Fixed a -> [ Fixed a] Source # enumFromThen :: Fixed a -> Fixed a -> [ Fixed a] Source # enumFromTo :: Fixed a -> Fixed a -> [ Fixed a] Source # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [ Fixed a] Source #
Enum ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods succ :: Proxy s -> Proxy s Source # pred :: Proxy s -> Proxy s Source # toEnum :: Int -> Proxy s Source # fromEnum :: Proxy s -> Int Source # enumFrom :: Proxy s -> [ Proxy s] Source # enumFromThen :: Proxy s -> Proxy s -> [ Proxy s] Source # enumFromTo :: Proxy s -> Proxy s -> [ Proxy s] Source # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [ Proxy s] Source #
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 Source # pred :: Const a b -> Const a b Source # toEnum :: Int -> Const a b Source # fromEnum :: Const a b -> Int Source # enumFrom :: Const a b -> [ Const a b] Source # enumFromThen :: Const a b -> Const a b -> [ Const a b] Source # enumFromTo :: Const a b -> Const a b -> [ Const a b] Source # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [ Const a b] Source #
Enum (f a) => Enum ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods succ :: Ap f a -> Ap f a Source # pred :: Ap f a -> Ap f a Source # toEnum :: Int -> Ap f a Source # fromEnum :: Ap f a -> Int Source # enumFrom :: Ap f a -> [ Ap f a] Source # enumFromThen :: Ap f a -> Ap f a -> [ Ap f a] Source # enumFromTo :: Ap f a -> Ap f a -> [ Ap f a] Source # enumFromThenTo :: Ap f a -> Ap f a -> Ap f a -> [ Ap f a] Source #
Enum (f a) => Enum ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods succ :: Alt f a -> Alt f a Source # pred :: Alt f a -> Alt f a Source # toEnum :: Int -> Alt f a Source # fromEnum :: Alt f a -> Int Source # enumFrom :: Alt f a -> [ Alt f a] Source # enumFromThen :: Alt f a -> Alt f a -> [ Alt f a] Source # enumFromTo :: Alt f a -> Alt f a -> [ Alt f a] Source # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [ Alt f a] Source #
Coercible a b => Enum ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods succ :: Coercion a b -> Coercion a b Source # pred :: Coercion a b -> Coercion a b Source # toEnum :: Int -> Coercion a b Source # fromEnum :: Coercion a b -> Int Source # enumFrom :: Coercion a b -> [ Coercion a b] Source # enumFromThen :: Coercion a b -> Coercion a b -> [ Coercion a b] Source # enumFromTo :: Coercion a b -> Coercion a b -> [ Coercion a b] Source # enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [ Coercion a b] Source #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b Source # pred :: (a :~: b) -> a :~: b Source # toEnum :: Int -> a :~: b Source # fromEnum :: (a :~: b) -> Int Source # enumFrom :: (a :~: b) -> [a :~: b] Source # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] Source # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] Source # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] Source #
Enum a => Enum ( Tagged s a)
Instance details Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a Source # pred :: Tagged s a -> Tagged s a Source # toEnum :: Int -> Tagged s a Source # fromEnum :: Tagged s a -> Int Source # enumFrom :: Tagged s a -> [ Tagged s a] Source # enumFromThen :: Tagged s a -> Tagged s a -> [ Tagged s a] Source # enumFromTo :: Tagged s a -> Tagged s a -> [ Tagged s a] Source # enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [ Tagged s a] Source #
a ~~ b => Enum (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b Source # pred :: (a :~~: b) -> a :~~: b Source # toEnum :: Int -> a :~~: b Source # fromEnum :: (a :~~: b) -> Int Source # enumFrom :: (a :~~: b) -> [a :~~: b] Source # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] Source # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] Source # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] Source #

class Eq a where Source #

The Eq class defines equality ( == ) and inequality ( /= ). All the basic datatypes exported by the Prelude are instances of Eq , and Eq may be derived for any datatype whose constituents are also instances of Eq .

The Haskell Report defines no laws for Eq . However, == is customarily expected to implement an equivalence relationship where two values comparing equal are indistinguishable by "public" functions, with a "public" function being one not allowing to see implementation details. For example, for a type representing non-normalised natural numbers modulo 100, a "public" function doesn't make the difference between 1 and 201. It is expected to have the following properties:

Reflexivity: x == x = True
Symmetry: x == y = y == x
Transitivity: if x == y && y == z = True , then x == z = True
Substitutivity: if x == y = True and f is a "public" function whose return type is an instance of Eq , then f x == f y = True
Negation: x /= y = not (x == y)

Minimal complete definition: either == or /= .

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4 Source #

(/=) :: a -> a -> Bool infix 4 Source #

Instances

Instances details

Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool Source # (/=) :: Bool -> Bool -> Bool Source #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool Source # (/=) :: Char -> Char -> Bool Source #
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 Source # (/=) :: Double -> Double -> Bool Source #
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 substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool Source # (/=) :: Float -> Float -> Bool Source #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool Source # (/=) :: Int -> Int -> Bool Source #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool Source # (/=) :: Int8 -> Int8 -> Bool Source #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool Source # (/=) :: Int16 -> Int16 -> Bool Source #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool Source # (/=) :: Int32 -> Int32 -> Bool Source #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool Source # (/=) :: Int64 -> Int64 -> Bool Source #
Eq Integer
Instance details Defined in GHC.Integer.Type Methods (==) :: Integer -> Integer -> Bool Source # (/=) :: Integer -> Integer -> Bool Source #
Eq Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Natural Methods (==) :: Natural -> Natural -> Bool Source # (/=) :: Natural -> Natural -> Bool Source #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool Source # (/=) :: Ordering -> Ordering -> Bool Source #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool Source # (/=) :: Word -> Word -> Bool Source #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool Source # (/=) :: Word8 -> Word8 -> Bool Source #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool Source # (/=) :: Word16 -> Word16 -> Bool Source #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool Source # (/=) :: Word32 -> Word32 -> Bool Source #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool Source # (/=) :: Word64 -> Word64 -> Bool Source #
Eq SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool Source #
Eq Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Exp -> Exp -> Bool Source # (/=) :: Exp -> Exp -> Bool Source #
Eq Match
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Match -> Match -> Bool Source # (/=) :: Match -> Match -> Bool Source #
Eq Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Clause -> Clause -> Bool Source # (/=) :: Clause -> Clause -> Bool Source #
Eq Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pat -> Pat -> Bool Source # (/=) :: Pat -> Pat -> Bool Source #
Eq Type
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Type -> Type -> Bool Source # (/=) :: Type -> Type -> Bool Source #
Eq Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Dec -> Dec -> Bool Source # (/=) :: Dec -> Dec -> Bool Source #
Eq Name
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Name -> Name -> Bool Source # (/=) :: Name -> Name -> Bool Source #
Eq FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FunDep -> FunDep -> Bool Source # (/=) :: FunDep -> FunDep -> Bool Source #
Eq InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool Source #
Eq Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Overlap -> Overlap -> Bool Source # (/=) :: Overlap -> Overlap -> Bool Source #
Eq ()
Instance details Defined in GHC.Classes Methods (==) :: () -> () -> Bool Source # (/=) :: () -> () -> Bool Source #
Eq TyCon
Instance details Defined in GHC.Classes Methods (==) :: TyCon -> TyCon -> Bool Source # (/=) :: TyCon -> TyCon -> Bool Source #
Eq Module
Instance details Defined in GHC.Classes Methods (==) :: Module -> Module -> Bool Source # (/=) :: Module -> Module -> Bool Source #
Eq TrName
Instance details Defined in GHC.Classes Methods (==) :: TrName -> TrName -> Bool Source # (/=) :: TrName -> TrName -> Bool Source #
Eq ByteString
Instance details Defined in Data.ByteString.Internal Methods (==) :: ByteString -> ByteString -> Bool Source # (/=) :: ByteString -> ByteString -> Bool Source #
Eq ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods (==) :: ByteString -> ByteString -> Bool Source # (/=) :: ByteString -> ByteString -> Bool Source #
Eq Builder
Instance details Defined in Data.Text.Internal.Builder Methods (==) :: Builder -> Builder -> Bool Source # (/=) :: Builder -> Builder -> Bool Source #
Eq Scientific	Scientific numbers can be safely compared for equality. No magnitude `10^e` is calculated so there's no risk of a blowup in space or time when comparing scientific numbers coming from untrusted sources.
Instance details Defined in Data.Scientific Methods (==) :: Scientific -> Scientific -> Bool Source # (/=) :: Scientific -> Scientific -> Bool Source #
Eq UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods (==) :: UTCTime -> UTCTime -> Bool Source # (/=) :: UTCTime -> UTCTime -> Bool Source #
Eq JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: JSONPathElement -> JSONPathElement -> Bool Source # (/=) :: JSONPathElement -> JSONPathElement -> Bool Source #
Eq Value
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Value -> Value -> Bool Source # (/=) :: Value -> Value -> Bool Source #
Eq DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: DotNetTime -> DotNetTime -> Bool Source # (/=) :: DotNetTime -> DotNetTime -> Bool Source #
Eq SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: SumEncoding -> SumEncoding -> Bool Source # (/=) :: SumEncoding -> SumEncoding -> Bool Source #
Eq Key
Instance details Defined in Data.Aeson.Key Methods (==) :: Key -> Key -> Bool Source # (/=) :: Key -> Key -> Bool Source #
Eq Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool Source # (/=) :: Handle -> Handle -> Bool Source #
Eq ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadId -> ThreadId -> Bool Source # (/=) :: ThreadId -> ThreadId -> Bool Source #
Eq AsyncCancelled
Instance details Defined in Control.Concurrent.Async Methods (==) :: AsyncCancelled -> AsyncCancelled -> Bool Source # (/=) :: AsyncCancelled -> AsyncCancelled -> Bool Source #
Eq Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: Pos -> Pos -> Bool Source # (/=) :: Pos -> Pos -> Bool Source #
Eq More
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: More -> More -> Bool Source # (/=) :: More -> More -> Bool Source #
Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool Source # (/=) :: Void -> Void -> Bool Source #
Eq SpecConstrAnnotation	Since: base-4.3.0.0
Instance details Defined in GHC.Exts Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool Source # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool Source #
Eq Version	Since: base-2.1
Instance details Defined in Data.Version Methods (==) :: Version -> Version -> Bool Source # (/=) :: Version -> Version -> Bool Source #
Eq BlockReason	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: BlockReason -> BlockReason -> Bool Source # (/=) :: BlockReason -> BlockReason -> Bool Source #
Eq ThreadStatus	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadStatus -> ThreadStatus -> Bool Source # (/=) :: ThreadStatus -> ThreadStatus -> Bool Source #
Eq CDev
Instance details Defined in System.Posix.Types Methods (==) :: CDev -> CDev -> Bool Source # (/=) :: CDev -> CDev -> Bool Source #
Eq CIno
Instance details Defined in System.Posix.Types Methods (==) :: CIno -> CIno -> Bool Source # (/=) :: CIno -> CIno -> Bool Source #
Eq CMode
Instance details Defined in System.Posix.Types Methods (==) :: CMode -> CMode -> Bool Source # (/=) :: CMode -> CMode -> Bool Source #
Eq COff
Instance details Defined in System.Posix.Types Methods (==) :: COff -> COff -> Bool Source # (/=) :: COff -> COff -> Bool Source #
Eq CPid
Instance details Defined in System.Posix.Types Methods (==) :: CPid -> CPid -> Bool Source # (/=) :: CPid -> CPid -> Bool Source #
Eq CSsize
Instance details Defined in System.Posix.Types Methods (==) :: CSsize -> CSsize -> Bool Source # (/=) :: CSsize -> CSsize -> Bool Source #
Eq CGid
Instance details Defined in System.Posix.Types Methods (==) :: CGid -> CGid -> Bool Source # (/=) :: CGid -> CGid -> Bool Source #
Eq CNlink
Instance details Defined in System.Posix.Types Methods (==) :: CNlink -> CNlink -> Bool Source # (/=) :: CNlink -> CNlink -> Bool Source #
Eq CUid
Instance details Defined in System.Posix.Types Methods (==) :: CUid -> CUid -> Bool Source # (/=) :: CUid -> CUid -> Bool Source #
Eq CCc
Instance details Defined in System.Posix.Types Methods (==) :: CCc -> CCc -> Bool Source # (/=) :: CCc -> CCc -> Bool Source #
Eq CSpeed
Instance details Defined in System.Posix.Types Methods (==) :: CSpeed -> CSpeed -> Bool Source # (/=) :: CSpeed -> CSpeed -> Bool Source #
Eq CTcflag
Instance details Defined in System.Posix.Types Methods (==) :: CTcflag -> CTcflag -> Bool Source # (/=) :: CTcflag -> CTcflag -> Bool Source #
Eq CRLim
Instance details Defined in System.Posix.Types Methods (==) :: CRLim -> CRLim -> Bool Source # (/=) :: CRLim -> CRLim -> Bool Source #
Eq CBlkSize
Instance details Defined in System.Posix.Types Methods (==) :: CBlkSize -> CBlkSize -> Bool Source # (/=) :: CBlkSize -> CBlkSize -> Bool Source #
Eq CBlkCnt
Instance details Defined in System.Posix.Types Methods (==) :: CBlkCnt -> CBlkCnt -> Bool Source # (/=) :: CBlkCnt -> CBlkCnt -> Bool Source #
Eq CClockId
Instance details Defined in System.Posix.Types Methods (==) :: CClockId -> CClockId -> Bool Source # (/=) :: CClockId -> CClockId -> Bool Source #
Eq CFsBlkCnt
Instance details Defined in System.Posix.Types Methods (==) :: CFsBlkCnt -> CFsBlkCnt -> Bool Source # (/=) :: CFsBlkCnt -> CFsBlkCnt -> Bool Source #
Eq CFsFilCnt
Instance details Defined in System.Posix.Types Methods (==) :: CFsFilCnt -> CFsFilCnt -> Bool Source # (/=) :: CFsFilCnt -> CFsFilCnt -> Bool Source #
Eq CId
Instance details Defined in System.Posix.Types Methods (==) :: CId -> CId -> Bool Source # (/=) :: CId -> CId -> Bool Source #
Eq CKey
Instance details Defined in System.Posix.Types Methods (==) :: CKey -> CKey -> Bool Source # (/=) :: CKey -> CKey -> Bool Source #
Eq CSocklen
Instance details Defined in System.Posix.Types Methods (==) :: CSocklen -> CSocklen -> Bool Source # (/=) :: CSocklen -> CSocklen -> Bool Source #
Eq CNfds
Instance details Defined in System.Posix.Types Methods (==) :: CNfds -> CNfds -> Bool Source # (/=) :: CNfds -> CNfds -> Bool Source #
Eq Fd
Instance details Defined in System.Posix.Types Methods (==) :: Fd -> Fd -> Bool Source # (/=) :: Fd -> Fd -> Bool Source #
Eq AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool Source # (/=) :: AsyncException -> AsyncException -> Bool Source #
Eq ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool Source # (/=) :: ArrayException -> ArrayException -> Bool Source #
Eq ExitCode
Instance details Defined in GHC.IO.Exception Methods (==) :: ExitCode -> ExitCode -> Bool Source # (/=) :: ExitCode -> ExitCode -> Bool Source #
Eq IOErrorType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOErrorType -> IOErrorType -> Bool Source # (/=) :: IOErrorType -> IOErrorType -> Bool Source #
Eq BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: BufferMode -> BufferMode -> Bool Source # (/=) :: BufferMode -> BufferMode -> Bool Source #
Eq Newline	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Newline -> Newline -> Bool Source # (/=) :: Newline -> Newline -> Bool Source #
Eq NewlineMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: NewlineMode -> NewlineMode -> Bool Source # (/=) :: NewlineMode -> NewlineMode -> Bool Source #
Eq MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool Source # (/=) :: MaskingState -> MaskingState -> Bool Source #
Eq IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOException -> IOException -> Bool Source # (/=) :: IOException -> IOException -> Bool Source #
Eq ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods (==) :: ErrorCall -> ErrorCall -> Bool Source # (/=) :: ErrorCall -> ErrorCall -> Bool Source #
Eq ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool Source # (/=) :: ArithException -> ArithException -> Bool Source #
Eq All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: All -> All -> Bool Source # (/=) :: All -> All -> Bool Source #
Eq Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Any -> Any -> Bool Source # (/=) :: Any -> Any -> Bool Source #
Eq Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Fixity -> Fixity -> Bool Source # (/=) :: Fixity -> Fixity -> Bool Source #
Eq Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool Source # (/=) :: Associativity -> Associativity -> Bool Source #
Eq SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #
Eq SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceStrictness -> SourceStrictness -> Bool Source # (/=) :: SourceStrictness -> SourceStrictness -> Bool Source #
Eq DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool Source #
Eq SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods (==) :: SomeSymbol -> SomeSymbol -> Bool Source # (/=) :: SomeSymbol -> SomeSymbol -> Bool Source #
Eq SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods (==) :: SomeNat -> SomeNat -> Bool Source # (/=) :: SomeNat -> SomeNat -> Bool Source #
Eq CChar
Instance details Defined in Foreign.C.Types Methods (==) :: CChar -> CChar -> Bool Source # (/=) :: CChar -> CChar -> Bool Source #
Eq CSChar
Instance details Defined in Foreign.C.Types Methods (==) :: CSChar -> CSChar -> Bool Source # (/=) :: CSChar -> CSChar -> Bool Source #
Eq CUChar
Instance details Defined in Foreign.C.Types Methods (==) :: CUChar -> CUChar -> Bool Source # (/=) :: CUChar -> CUChar -> Bool Source #
Eq CShort
Instance details Defined in Foreign.C.Types Methods (==) :: CShort -> CShort -> Bool Source # (/=) :: CShort -> CShort -> Bool Source #
Eq CUShort
Instance details Defined in Foreign.C.Types Methods (==) :: CUShort -> CUShort -> Bool Source # (/=) :: CUShort -> CUShort -> Bool Source #
Eq CInt
Instance details Defined in Foreign.C.Types Methods (==) :: CInt -> CInt -> Bool Source # (/=) :: CInt -> CInt -> Bool Source #
Eq CUInt
Instance details Defined in Foreign.C.Types Methods (==) :: CUInt -> CUInt -> Bool Source # (/=) :: CUInt -> CUInt -> Bool Source #
Eq CLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLong -> CLong -> Bool Source # (/=) :: CLong -> CLong -> Bool Source #
Eq CULong
Instance details Defined in Foreign.C.Types Methods (==) :: CULong -> CULong -> Bool Source # (/=) :: CULong -> CULong -> Bool Source #
Eq CLLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLLong -> CLLong -> Bool Source # (/=) :: CLLong -> CLLong -> Bool Source #
Eq CULLong
Instance details Defined in Foreign.C.Types Methods (==) :: CULLong -> CULLong -> Bool Source # (/=) :: CULLong -> CULLong -> Bool Source #
Eq CBool
Instance details Defined in Foreign.C.Types Methods (==) :: CBool -> CBool -> Bool Source # (/=) :: CBool -> CBool -> Bool Source #
Eq CFloat
Instance details Defined in Foreign.C.Types Methods (==) :: CFloat -> CFloat -> Bool Source # (/=) :: CFloat -> CFloat -> Bool Source #
Eq CDouble
Instance details Defined in Foreign.C.Types Methods (==) :: CDouble -> CDouble -> Bool Source # (/=) :: CDouble -> CDouble -> Bool Source #
Eq CPtrdiff
Instance details Defined in Foreign.C.Types Methods (==) :: CPtrdiff -> CPtrdiff -> Bool Source # (/=) :: CPtrdiff -> CPtrdiff -> Bool Source #
Eq CSize
Instance details Defined in Foreign.C.Types Methods (==) :: CSize -> CSize -> Bool Source # (/=) :: CSize -> CSize -> Bool Source #
Eq CWchar
Instance details Defined in Foreign.C.Types Methods (==) :: CWchar -> CWchar -> Bool Source # (/=) :: CWchar -> CWchar -> Bool Source #
Eq CSigAtomic
Instance details Defined in Foreign.C.Types Methods (==) :: CSigAtomic -> CSigAtomic -> Bool Source # (/=) :: CSigAtomic -> CSigAtomic -> Bool Source #
Eq CClock
Instance details Defined in Foreign.C.Types Methods (==) :: CClock -> CClock -> Bool Source # (/=) :: CClock -> CClock -> Bool Source #
Eq CTime
Instance details Defined in Foreign.C.Types Methods (==) :: CTime -> CTime -> Bool Source # (/=) :: CTime -> CTime -> Bool Source #
Eq CUSeconds
Instance details Defined in Foreign.C.Types Methods (==) :: CUSeconds -> CUSeconds -> Bool Source # (/=) :: CUSeconds -> CUSeconds -> Bool Source #
Eq CSUSeconds
Instance details Defined in Foreign.C.Types Methods (==) :: CSUSeconds -> CSUSeconds -> Bool Source # (/=) :: CSUSeconds -> CSUSeconds -> Bool Source #
Eq CIntPtr
Instance details Defined in Foreign.C.Types Methods (==) :: CIntPtr -> CIntPtr -> Bool Source # (/=) :: CIntPtr -> CIntPtr -> Bool Source #
Eq CUIntPtr
Instance details Defined in Foreign.C.Types Methods (==) :: CUIntPtr -> CUIntPtr -> Bool Source # (/=) :: CUIntPtr -> CUIntPtr -> Bool Source #
Eq CIntMax
Instance details Defined in Foreign.C.Types Methods (==) :: CIntMax -> CIntMax -> Bool Source # (/=) :: CIntMax -> CIntMax -> Bool Source #
Eq CUIntMax
Instance details Defined in Foreign.C.Types Methods (==) :: CUIntMax -> CUIntMax -> Bool Source # (/=) :: CUIntMax -> CUIntMax -> Bool Source #
Eq WordPtr
Instance details Defined in Foreign.Ptr Methods (==) :: WordPtr -> WordPtr -> Bool Source # (/=) :: WordPtr -> WordPtr -> Bool Source #
Eq IntPtr
Instance details Defined in Foreign.Ptr Methods (==) :: IntPtr -> IntPtr -> Bool Source # (/=) :: IntPtr -> IntPtr -> Bool Source #
Eq IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods (==) :: IOMode -> IOMode -> Bool Source # (/=) :: IOMode -> IOMode -> Bool Source #
Eq GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods (==) :: GeneralCategory -> GeneralCategory -> Bool Source # (/=) :: GeneralCategory -> GeneralCategory -> Bool Source #
Eq SrcLoc	Since: base-4.9.0.0
Instance details Defined in GHC.Stack.Types Methods (==) :: SrcLoc -> SrcLoc -> Bool Source # (/=) :: SrcLoc -> SrcLoc -> Bool Source #
Eq ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods (==) :: ShortByteString -> ShortByteString -> Bool Source # (/=) :: ShortByteString -> ShortByteString -> Bool Source #
Eq JSValue
Instance details Defined in Text.JSON.Canonical.Types Methods (==) :: JSValue -> JSValue -> Bool Source # (/=) :: JSValue -> JSValue -> Bool Source #
Eq JSString
Instance details Defined in Text.JSON.Canonical.Types Methods (==) :: JSString -> JSString -> Bool Source # (/=) :: JSString -> JSString -> Bool Source #
Eq Int54
Instance details Defined in Text.JSON.Canonical.Types Methods (==) :: Int54 -> Int54 -> Bool Source # (/=) :: Int54 -> Int54 -> Bool Source #
Eq ByteArray	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.ByteArray Methods (==) :: ByteArray -> ByteArray -> Bool Source # (/=) :: ByteArray -> ByteArray -> Bool Source #
Eq TokenType
Instance details Defined in Codec.CBOR.Decoding Methods (==) :: TokenType -> TokenType -> Bool Source # (/=) :: TokenType -> TokenType -> Bool Source #
Eq ByteArray
Instance details Defined in Codec.CBOR.ByteArray Methods (==) :: ByteArray -> ByteArray -> Bool Source # (/=) :: ByteArray -> ByteArray -> Bool Source #
Eq SlicedByteArray
Instance details Defined in Codec.CBOR.ByteArray.Sliced Methods (==) :: SlicedByteArray -> SlicedByteArray -> Bool Source # (/=) :: SlicedByteArray -> SlicedByteArray -> Bool Source #
Eq IntSet
Instance details Defined in Data.IntSet.Internal Methods (==) :: IntSet -> IntSet -> Bool Source # (/=) :: IntSet -> IntSet -> Bool Source #
Eq DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods (==) :: DiffTime -> DiffTime -> Bool Source # (/=) :: DiffTime -> DiffTime -> Bool Source #
Eq NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (==) :: NominalDiffTime -> NominalDiffTime -> Bool Source # (/=) :: NominalDiffTime -> NominalDiffTime -> Bool Source #
Eq Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods (==) :: Extension -> Extension -> Bool Source # (/=) :: Extension -> Extension -> Bool Source #
Eq ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool Source # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool Source #
Eq PrimType
Instance details Defined in GHC.Exts.Heap.Closures Methods (==) :: PrimType -> PrimType -> Bool Source # (/=) :: PrimType -> PrimType -> Bool Source #
Eq ClosureType
Instance details Defined in GHC.Exts.Heap.ClosureTypes Methods (==) :: ClosureType -> ClosureType -> Bool Source # (/=) :: ClosureType -> ClosureType -> Bool Source #
Eq BigNat
Instance details Defined in GHC.Integer.Type Methods (==) :: BigNat -> BigNat -> Bool Source # (/=) :: BigNat -> BigNat -> Bool Source #
Eq Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods (==) :: Doc -> Doc -> Bool Source # (/=) :: Doc -> Doc -> Bool Source #
Eq TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: TextDetails -> TextDetails -> Bool Source # (/=) :: TextDetails -> TextDetails -> Bool Source #
Eq Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Style -> Style -> Bool Source # (/=) :: Style -> Style -> Bool Source #
Eq Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Mode -> Mode -> Bool Source # (/=) :: Mode -> Mode -> Bool Source #
Eq UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool Source # (/=) :: UnicodeException -> UnicodeException -> Bool Source #
Eq StdGen
Instance details Defined in System.Random.Internal Methods (==) :: StdGen -> StdGen -> Bool Source # (/=) :: StdGen -> StdGen -> Bool Source #
Eq ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModName -> ModName -> Bool Source # (/=) :: ModName -> ModName -> Bool Source #
Eq PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PkgName -> PkgName -> Bool Source # (/=) :: PkgName -> PkgName -> Bool Source #
Eq Module
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Module -> Module -> Bool Source # (/=) :: Module -> Module -> Bool Source #
Eq OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: OccName -> OccName -> Bool Source # (/=) :: OccName -> OccName -> Bool Source #
Eq NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameFlavour -> NameFlavour -> Bool Source # (/=) :: NameFlavour -> NameFlavour -> Bool Source #
Eq NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameSpace -> NameSpace -> Bool Source # (/=) :: NameSpace -> NameSpace -> Bool Source #
Eq Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Loc -> Loc -> Bool Source # (/=) :: Loc -> Loc -> Bool Source #
Eq Info
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Info -> Info -> Bool Source # (/=) :: Info -> Info -> Bool Source #
Eq ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModuleInfo -> ModuleInfo -> Bool Source # (/=) :: ModuleInfo -> ModuleInfo -> Bool Source #
Eq Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Fixity -> Fixity -> Bool Source # (/=) :: Fixity -> Fixity -> Bool Source #
Eq FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool Source # (/=) :: FixityDirection -> FixityDirection -> Bool Source #
Eq Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Lit -> Lit -> Bool Source # (/=) :: Lit -> Lit -> Bool Source #
Eq Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Bytes -> Bytes -> Bool Source # (/=) :: Bytes -> Bytes -> Bool Source #
Eq Body
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Body -> Body -> Bool Source # (/=) :: Body -> Body -> Bool Source #
Eq Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Guard -> Guard -> Bool Source # (/=) :: Guard -> Guard -> Bool Source #
Eq Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Stmt -> Stmt -> Bool Source # (/=) :: Stmt -> Stmt -> Bool Source #
Eq Range
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Range -> Range -> Bool Source # (/=) :: Range -> Range -> Bool Source #
Eq DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivClause -> DerivClause -> Bool Source # (/=) :: DerivClause -> DerivClause -> Bool Source #
Eq DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivStrategy -> DerivStrategy -> Bool Source # (/=) :: DerivStrategy -> DerivStrategy -> Bool Source #
Eq TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source #
Eq TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TySynEqn -> TySynEqn -> Bool Source # (/=) :: TySynEqn -> TySynEqn -> Bool Source #
Eq Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Foreign -> Foreign -> Bool Source # (/=) :: Foreign -> Foreign -> Bool Source #
Eq Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Callconv -> Callconv -> Bool Source # (/=) :: Callconv -> Callconv -> Bool Source #
Eq Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Safety -> Safety -> Bool Source # (/=) :: Safety -> Safety -> Bool Source #
Eq Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pragma -> Pragma -> Bool Source # (/=) :: Pragma -> Pragma -> Bool Source #
Eq Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Inline -> Inline -> Bool Source # (/=) :: Inline -> Inline -> Bool Source #
Eq RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleMatch -> RuleMatch -> Bool Source # (/=) :: RuleMatch -> RuleMatch -> Bool Source #
Eq Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Phases -> Phases -> Bool Source # (/=) :: Phases -> Phases -> Bool Source #
Eq RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleBndr -> RuleBndr -> Bool Source # (/=) :: RuleBndr -> RuleBndr -> Bool Source #
Eq AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnTarget -> AnnTarget -> Bool Source # (/=) :: AnnTarget -> AnnTarget -> Bool Source #
Eq SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #
Eq SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceStrictness -> SourceStrictness -> Bool Source # (/=) :: SourceStrictness -> SourceStrictness -> Bool Source #
Eq DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool Source #
Eq Con
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Con -> Con -> Bool Source # (/=) :: Con -> Con -> Bool Source #
Eq Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Bang -> Bang -> Bool Source # (/=) :: Bang -> Bang -> Bool Source #
Eq PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynDir -> PatSynDir -> Bool Source # (/=) :: PatSynDir -> PatSynDir -> Bool Source #
Eq PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynArgs -> PatSynArgs -> Bool Source # (/=) :: PatSynArgs -> PatSynArgs -> Bool Source #
Eq TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyVarBndr -> TyVarBndr -> Bool Source # (/=) :: TyVarBndr -> TyVarBndr -> Bool Source #
Eq FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool Source #
Eq TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyLit -> TyLit -> Bool Source # (/=) :: TyLit -> TyLit -> Bool Source #
Eq Role
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Role -> Role -> Bool Source # (/=) :: Role -> Role -> Bool Source #
Eq AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnLookup -> AnnLookup -> Bool Source # (/=) :: AnnLookup -> AnnLookup -> Bool Source #
Eq ShortText
Instance details Defined in Data.Text.Short.Internal Methods (==) :: ShortText -> ShortText -> Bool Source # (/=) :: ShortText -> ShortText -> Bool Source #
Eq LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods (==) :: LocalTime -> LocalTime -> Bool Source # (/=) :: LocalTime -> LocalTime -> Bool Source #
Eq TimeOfDay
Instance details Defined in Data.Time.LocalTime.Internal.TimeOfDay Methods (==) :: TimeOfDay -> TimeOfDay -> Bool Source # (/=) :: TimeOfDay -> TimeOfDay -> Bool Source #
Eq TimeZone
Instance details Defined in Data.Time.LocalTime.Internal.TimeZone Methods (==) :: TimeZone -> TimeZone -> Bool Source # (/=) :: TimeZone -> TimeZone -> Bool Source #
Eq UniversalTime
Instance details Defined in Data.Time.Clock.Internal.UniversalTime Methods (==) :: UniversalTime -> UniversalTime -> Bool Source # (/=) :: UniversalTime -> UniversalTime -> Bool Source #
Eq Day
Instance details Defined in Data.Time.Calendar.Days Methods (==) :: Day -> Day -> Bool Source # (/=) :: Day -> Day -> Bool Source #
Eq UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods (==) :: UnpackedUUID -> UnpackedUUID -> Bool Source # (/=) :: UnpackedUUID -> UnpackedUUID -> Bool Source #
Eq UUID
Instance details Defined in Data.UUID.Types.Internal Methods (==) :: UUID -> UUID -> Bool Source # (/=) :: UUID -> UUID -> Bool Source #
Eq CodePoint
Instance details Defined in Data.Text.Encoding Methods (==) :: CodePoint -> CodePoint -> Bool Source # (/=) :: CodePoint -> CodePoint -> Bool Source #
Eq DecoderState
Instance details Defined in Data.Text.Encoding Methods (==) :: DecoderState -> DecoderState -> Bool Source # (/=) :: DecoderState -> DecoderState -> Bool Source #
Eq B
Instance details Defined in Data.Text.Short.Internal Methods (==) :: B -> B -> Bool Source # (/=) :: B -> B -> Bool Source #
Eq CountFailure Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Size Methods (==) :: CountFailure -> CountFailure -> Bool Source # (/=) :: CountFailure -> CountFailure -> Bool Source #
Eq SchemaError Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods (==) :: SchemaError -> SchemaError -> Bool Source # (/=) :: SchemaError -> SchemaError -> Bool Source #
Eq a => Eq [a]
Instance details Defined in GHC.Classes Methods (==) :: [a] -> [a] -> Bool Source # (/=) :: [a] -> [a] -> Bool Source #
Eq a => Eq ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool Source # (/=) :: Maybe a -> Maybe a -> Bool Source #
Eq a => Eq ( Ratio a)	Since: base-2.1
Instance details Defined in GHC.Real Methods (==) :: Ratio a -> Ratio a -> Bool Source # (/=) :: Ratio a -> Ratio a -> Bool Source #
Eq ( StablePtr a)	Since: base-2.1
Instance details Defined in GHC.Stable Methods (==) :: StablePtr a -> StablePtr a -> Bool Source # (/=) :: StablePtr a -> StablePtr a -> Bool Source #
Eq ( Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods (==) :: Ptr a -> Ptr a -> Bool Source # (/=) :: Ptr a -> Ptr a -> Bool Source #
Eq ( FunPtr a)
Instance details Defined in GHC.Ptr Methods (==) :: FunPtr a -> FunPtr a -> Bool Source # (/=) :: FunPtr a -> FunPtr a -> Bool Source #
Eq p => Eq ( Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Par1 p -> Par1 p -> Bool Source # (/=) :: Par1 p -> Par1 p -> Bool Source #
Eq a => Eq ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods (==) :: Solo a -> Solo a -> Bool Source # (/=) :: Solo a -> Solo a -> Bool Source #
Eq a => Eq ( IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: IResult a -> IResult a -> Bool Source # (/=) :: IResult a -> IResult a -> Bool Source #
Eq a => Eq ( Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Result a -> Result a -> Bool Source # (/=) :: Result a -> Result a -> Bool Source #
Eq v => Eq ( KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods (==) :: KeyMap v -> KeyMap v -> Bool Source # (/=) :: KeyMap v -> KeyMap v -> Bool Source #
Eq ( Async a)
Instance details Defined in Control.Concurrent.Async Methods (==) :: Async a -> Async a -> Bool Source # (/=) :: Async a -> Async a -> Bool Source #
Eq a => Eq ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (==) :: Complex a -> Complex a -> Bool Source # (/=) :: Complex a -> Complex a -> Bool Source #
Eq a => Eq ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Min a -> Min a -> Bool Source # (/=) :: Min a -> Min a -> Bool Source #
Eq a => Eq ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Max a -> Max a -> Bool Source # (/=) :: Max a -> Max a -> Bool Source #
Eq a => Eq ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: First a -> First a -> Bool Source # (/=) :: First a -> First a -> Bool Source #
Eq a => Eq ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Last a -> Last a -> Bool Source # (/=) :: Last a -> Last a -> Bool Source #
Eq m => Eq ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source #
Eq a => Eq ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Option a -> Option a -> Bool Source # (/=) :: Option a -> Option a -> Bool Source #
Eq ( Chan a)	Since: base-4.4.0.0
Instance details Defined in Control.Concurrent.Chan Methods (==) :: Chan a -> Chan a -> Bool Source # (/=) :: Chan a -> Chan a -> Bool Source #
Eq a => Eq ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (==) :: ZipList a -> ZipList a -> Bool Source # (/=) :: ZipList a -> ZipList a -> Bool Source #
Eq a => Eq ( Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool Source # (/=) :: Identity a -> Identity a -> Bool Source #
Eq ( TVar a)	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: TVar a -> TVar a -> Bool Source # (/=) :: TVar a -> TVar a -> Bool Source #
Eq a => Eq ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: First a -> First a -> Bool Source # (/=) :: First a -> First a -> Bool Source #
Eq a => Eq ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: Last a -> Last a -> Bool Source # (/=) :: Last a -> Last a -> Bool Source #
Eq a => Eq ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Dual a -> Dual a -> Bool Source # (/=) :: Dual a -> Dual a -> Bool Source #
Eq a => Eq ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Sum a -> Sum a -> Bool Source # (/=) :: Sum a -> Sum a -> Bool Source #
Eq a => Eq ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Product a -> Product a -> Bool Source # (/=) :: Product a -> Product a -> Bool Source #
Eq a => Eq ( Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods (==) :: Down a -> Down a -> Bool Source # (/=) :: Down a -> Down a -> Bool Source #
Eq ( MVar a)	Since: base-4.1.0.0
Instance details Defined in GHC.MVar Methods (==) :: MVar a -> MVar a -> Bool Source # (/=) :: MVar a -> MVar a -> Bool Source #
Eq a => Eq ( NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (==) :: NonEmpty a -> NonEmpty a -> Bool Source # (/=) :: NonEmpty a -> NonEmpty a -> Bool Source #
Eq a => Eq ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods (==) :: IntMap a -> IntMap a -> Bool Source # (/=) :: IntMap a -> IntMap a -> Bool Source #
Eq a => Eq ( Tree a)
Instance details Defined in Data.Tree Methods (==) :: Tree a -> Tree a -> Bool Source # (/=) :: Tree a -> Tree a -> Bool Source #
Eq a => Eq ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: Seq a -> Seq a -> Bool Source # (/=) :: Seq a -> Seq a -> Bool Source #
Eq a => Eq ( ViewL a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: ViewL a -> ViewL a -> Bool Source # (/=) :: ViewL a -> ViewL a -> Bool Source #
Eq a => Eq ( ViewR a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: ViewR a -> ViewR a -> Bool Source # (/=) :: ViewR a -> ViewR a -> Bool Source #
Eq a => Eq ( Set a)
Instance details Defined in Data.Set.Internal Methods (==) :: Set a -> Set a -> Bool Source # (/=) :: Set a -> Set a -> Bool Source #
Eq1 f => Eq ( Fix f)
Instance details Defined in Data.Fix Methods (==) :: Fix f -> Fix f -> Bool Source # (/=) :: Fix f -> Fix f -> Bool Source #
( Functor f, Eq1 f) => Eq ( Mu f)
Instance details Defined in Data.Fix Methods (==) :: Mu f -> Mu f -> Bool Source # (/=) :: Mu f -> Mu f -> Bool Source #
( Functor f, Eq1 f) => Eq ( Nu f)
Instance details Defined in Data.Fix Methods (==) :: Nu f -> Nu f -> Bool Source # (/=) :: Nu f -> Nu f -> Bool Source #
Eq a => Eq ( DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods (==) :: DNonEmpty a -> DNonEmpty a -> Bool Source # (/=) :: DNonEmpty a -> DNonEmpty a -> Bool Source #
Eq a => Eq ( DList a)
Instance details Defined in Data.DList.Internal Methods (==) :: DList a -> DList a -> Bool Source # (/=) :: DList a -> DList a -> Bool Source #
Eq a => Eq ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods (==) :: Hex a -> Hex a -> Bool Source # (/=) :: Hex a -> Hex a -> Bool Source #
Eq a => Eq ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods (==) :: Shown a -> Shown a -> Bool Source # (/=) :: Shown a -> Shown a -> Bool Source #
Eq a => Eq ( Hashed a)	Uses precomputed hash to detect inequality faster
Instance details Defined in Data.Hashable.Class Methods (==) :: Hashed a -> Hashed a -> Bool Source # (/=) :: Hashed a -> Hashed a -> Bool Source #
Eq ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Doc a -> Doc a -> Bool Source # (/=) :: Doc a -> Doc a -> Bool Source #
Eq a => Eq ( AnnotDetails a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool Source # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool Source #
Eq a => Eq ( Span a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Span a -> Span a -> Bool Source # (/=) :: Span a -> Span a -> Bool Source #
( Eq a, Prim a) => Eq ( PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods (==) :: PrimArray a -> PrimArray a -> Bool Source # (/=) :: PrimArray a -> PrimArray a -> Bool Source #
Eq ( MutableByteArray s)
Instance details Defined in Data.Primitive.ByteArray Methods (==) :: MutableByteArray s -> MutableByteArray s -> Bool Source # (/=) :: MutableByteArray s -> MutableByteArray s -> Bool Source #
Eq a => Eq ( SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods (==) :: SmallArray a -> SmallArray a -> Bool Source # (/=) :: SmallArray a -> SmallArray a -> Bool Source #
Eq a => Eq ( Array a)
Instance details Defined in Data.Primitive.Array Methods (==) :: Array a -> Array a -> Bool Source # (/=) :: Array a -> Array a -> Bool Source #
Eq g => Eq ( AtomicGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: AtomicGen g -> AtomicGen g -> Bool Source # (/=) :: AtomicGen g -> AtomicGen g -> Bool Source #
Eq g => Eq ( IOGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: IOGen g -> IOGen g -> Bool Source # (/=) :: IOGen g -> IOGen g -> Bool Source #
Eq g => Eq ( STGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: STGen g -> STGen g -> Bool Source # (/=) :: STGen g -> STGen g -> Bool Source #
Eq g => Eq ( TGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: TGen g -> TGen g -> Bool Source # (/=) :: TGen g -> TGen g -> Bool Source #
Eq g => Eq ( StateGen g)
Instance details Defined in System.Random.Internal Methods (==) :: StateGen g -> StateGen g -> Bool Source # (/=) :: StateGen g -> StateGen g -> Bool Source #
Eq a => Eq ( Maybe a)
Instance details Defined in Data.Strict.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool Source # (/=) :: Maybe a -> Maybe a -> Bool Source #
Eq a => Eq ( HashSet a)	Note that, in the presence of hash collisions, equal `HashSet` s may behave differently, i.e. substitutivity may be violated: `>>>` `data D = A \| B deriving (Eq, Show)``>>>` `instance Hashable D where hashWithSalt salt _d = salt` `>>>` `x = fromList [A, B]``>>>` `y = fromList [B, A]` `>>>` `x == y`True `>>>` `toList x`[A,B] `>>>` `toList y`[B,A] In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals.
Instance details Defined in Data.HashSet.Internal Methods (==) :: HashSet a -> HashSet a -> Bool Source # (/=) :: HashSet a -> HashSet a -> Bool Source #
( Storable a, Eq a) => Eq ( Vector a)
Instance details Defined in Data.Vector.Storable Methods (==) :: Vector a -> Vector a -> Bool Source # (/=) :: Vector a -> Vector a -> Bool Source #
( Prim a, Eq a) => Eq ( Vector a)
Instance details Defined in Data.Vector.Primitive Methods (==) :: Vector a -> Vector a -> Bool Source # (/=) :: Vector a -> Vector a -> Bool Source #
Eq a => Eq ( Vector a)
Instance details Defined in Data.Vector Methods (==) :: Vector a -> Vector a -> Bool Source # (/=) :: Vector a -> Vector a -> Bool Source #
( Eq a, Eq b) => Eq ( Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods (==) :: Either a b -> Either a b -> Bool Source # (/=) :: Either a b -> Either a b -> Bool Source #
Eq ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: V1 p -> V1 p -> Bool Source # (/=) :: V1 p -> V1 p -> Bool Source #
Eq ( U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: U1 p -> U1 p -> Bool Source # (/=) :: U1 p -> U1 p -> Bool Source #
Eq ( TypeRep a)	Since: base-2.1
Instance details Defined in Data.Typeable.Internal Methods (==) :: TypeRep a -> TypeRep a -> Bool Source # (/=) :: TypeRep a -> TypeRep a -> Bool Source #
( Eq a, Eq b) => Eq (a, b)
Instance details Defined in GHC.Classes Methods (==) :: (a, b) -> (a, b) -> Bool Source # (/=) :: (a, b) -> (a, b) -> Bool Source #
( Eq k, Eq a) => Eq ( Map k a)
Instance details Defined in Data.Map.Internal Methods (==) :: Map k a -> Map k a -> Bool Source # (/=) :: Map k a -> Map k a -> Bool Source #
( Eq k, Eq v) => Eq ( HashMap k v)	Note that, in the presence of hash collisions, equal `HashMap` s may behave differently, i.e. substitutivity may be violated: `>>>` `data D = A \| B deriving (Eq, Show)``>>>` `instance Hashable D where hashWithSalt salt _d = salt` `>>>` `x = fromList [(A,1), (B,2)]``>>>` `y = fromList [(B,2), (A,1)]` `>>>` `x == y`True `>>>` `toList x`[(A,1),(B,2)] `>>>` `toList y`[(B,2),(A,1)] In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals.
Instance details Defined in Data.HashMap.Internal Methods (==) :: HashMap k v -> HashMap k v -> Bool Source # (/=) :: HashMap k v -> HashMap k v -> Bool Source #
( Ix ix, Eq e, IArray UArray e) => Eq ( UArray ix e)
Instance details Defined in Data.Array.Base Methods (==) :: UArray ix e -> UArray ix e -> Bool Source # (/=) :: UArray ix e -> UArray ix e -> Bool Source #
( Ix i, Eq e) => Eq ( Array i e)	Since: base-2.1
Instance details Defined in GHC.Arr Methods (==) :: Array i e -> Array i e -> Bool Source # (/=) :: Array i e -> Array i e -> Bool Source #
Eq ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (==) :: Fixed a -> Fixed a -> Bool Source # (/=) :: Fixed a -> Fixed a -> Bool Source #
Eq a => Eq ( Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Arg a b -> Arg a b -> Bool Source # (/=) :: Arg a b -> Arg a b -> Bool Source #
Eq ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (==) :: Proxy s -> Proxy s -> Bool Source # (/=) :: Proxy s -> Proxy s -> Bool Source #
( Eq1 m, Eq a) => Eq ( ListT m a)
Instance details Defined in Control.Monad.Trans.List Methods (==) :: ListT m a -> ListT m a -> Bool Source # (/=) :: ListT m a -> ListT m a -> Bool Source #
Eq ( MutablePrimArray s a)
Instance details Defined in Data.Primitive.PrimArray Methods (==) :: MutablePrimArray s a -> MutablePrimArray s a -> Bool Source # (/=) :: MutablePrimArray s a -> MutablePrimArray s a -> Bool Source #
Eq ( SmallMutableArray s a)
Instance details Defined in Data.Primitive.SmallArray Methods (==) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool Source # (/=) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool Source #
Eq ( MutableArray s a)
Instance details Defined in Data.Primitive.Array Methods (==) :: MutableArray s a -> MutableArray s a -> Bool Source # (/=) :: MutableArray s a -> MutableArray s a -> Bool Source #
( Eq a, Eq b) => Eq ( These a b)
Instance details Defined in Data.These Methods (==) :: These a b -> These a b -> Bool Source # (/=) :: These a b -> These a b -> Bool Source #
( Eq a, Eq b) => Eq ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods (==) :: Pair a b -> Pair a b -> Bool Source # (/=) :: Pair a b -> Pair a b -> Bool Source #
( Eq a, Eq b) => Eq ( These a b)
Instance details Defined in Data.Strict.These Methods (==) :: These a b -> These a b -> Bool Source # (/=) :: These a b -> These a b -> Bool Source #
( Eq a, Eq b) => Eq ( Either a b)
Instance details Defined in Data.Strict.Either Methods (==) :: Either a b -> Either a b -> Bool Source # (/=) :: Either a b -> Either a b -> Bool Source #
( Eq1 m, Eq a) => Eq ( MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods (==) :: MaybeT m a -> MaybeT m a -> Bool Source # (/=) :: MaybeT m a -> MaybeT m a -> Bool Source #
( Eq k, Eq v) => Eq ( Leaf k v)
Instance details Defined in Data.HashMap.Internal Methods (==) :: Leaf k v -> Leaf k v -> Bool Source # (/=) :: Leaf k v -> Leaf k v -> Bool Source #
Eq (f p) => Eq ( Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Rec1 f p -> Rec1 f p -> Bool Source # (/=) :: Rec1 f p -> Rec1 f p -> Bool Source #
Eq ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (/=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source #
Eq ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool Source # (/=) :: URec Char p -> URec Char p -> Bool Source #
Eq ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool Source # (/=) :: URec Double p -> URec Double p -> Bool Source #
Eq ( URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool Source # (/=) :: URec Float p -> URec Float p -> Bool Source #
Eq ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool Source # (/=) :: URec Int p -> URec Int p -> Bool Source #
Eq ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool Source # (/=) :: URec Word p -> URec Word p -> Bool Source #
( Eq a, Eq b, Eq c) => Eq (a, b, c)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c) -> (a, b, c) -> Bool Source # (/=) :: (a, b, c) -> (a, b, c) -> Bool Source #
Eq ( STUArray s i e)
Instance details Defined in Data.Array.Base Methods (==) :: STUArray s i e -> STUArray s i e -> Bool Source # (/=) :: STUArray s i e -> STUArray s i e -> Bool Source #
Eq ( STArray s i e)	Since: base-2.1
Instance details Defined in GHC.Arr Methods (==) :: STArray s i e -> STArray s i e -> Bool Source # (/=) :: STArray s i e -> STArray s i e -> Bool Source #
Eq a => Eq ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool Source # (/=) :: Const a b -> Const a b -> Bool Source #
Eq (f a) => Eq ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (==) :: Ap f a -> Ap f a -> Bool Source # (/=) :: Ap f a -> Ap f a -> Bool Source #
Eq (f a) => Eq ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Alt f a -> Alt f a -> Bool Source # (/=) :: Alt f a -> Alt f a -> Bool Source #
Eq ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods (==) :: Coercion a b -> Coercion a b -> Bool Source # (/=) :: Coercion a b -> Coercion a b -> Bool Source #
Eq (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~: b) -> (a :~: b) -> Bool Source # (/=) :: (a :~: b) -> (a :~: b) -> Bool Source #
( Eq1 f, Eq a) => Eq ( IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods (==) :: IdentityT f a -> IdentityT f a -> Bool Source # (/=) :: IdentityT f a -> IdentityT f a -> Bool Source #
( Eq e, Eq1 m, Eq a) => Eq ( ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods (==) :: ErrorT e m a -> ErrorT e m a -> Bool Source # (/=) :: ErrorT e m a -> ErrorT e m a -> Bool Source #
( Eq e, Eq1 m, Eq a) => Eq ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool Source #
( Eq w, Eq1 m, Eq a) => Eq ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods (==) :: WriterT w m a -> WriterT w m a -> Bool Source # (/=) :: WriterT w m a -> WriterT w m a -> Bool Source #
( Eq w, Eq1 m, Eq a) => Eq ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods (==) :: WriterT w m a -> WriterT w m a -> Bool Source # (/=) :: WriterT w m a -> WriterT w m a -> Bool Source #
Eq b => Eq ( Tagged s b)
Instance details Defined in Data.Tagged Methods (==) :: Tagged s b -> Tagged s b -> Bool Source # (/=) :: Tagged s b -> Tagged s b -> Bool Source #
( Eq1 f, Eq1 g, Eq a) => Eq ( These1 f g a)
Instance details Defined in Data.Functor.These Methods (==) :: These1 f g a -> These1 f g a -> Bool Source # (/=) :: These1 f g a -> These1 f g a -> Bool Source #
Eq c => Eq ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: K1 i c p -> K1 i c p -> Bool Source # (/=) :: K1 i c p -> K1 i c p -> Bool Source #
( Eq (f p), Eq (g p)) => Eq ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool Source #
( Eq (f p), Eq (g p)) => Eq ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :: g) p -> (f :: g) p -> Bool Source # (/=) :: (f :: g) p -> (f :: g) p -> Bool Source #
( Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # (/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source #
( Eq1 f, Eq1 g, Eq a) => Eq ( Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods (==) :: Product f g a -> Product f g a -> Bool Source # (/=) :: Product f g a -> Product f g a -> Bool Source #
( Eq1 f, Eq1 g, Eq a) => Eq ( Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods (==) :: Sum f g a -> Sum f g a -> Bool Source # (/=) :: Sum f g a -> Sum f g a -> Bool Source #
Eq (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~~: b) -> (a :~~: b) -> Bool Source # (/=) :: (a :~~: b) -> (a :~~: b) -> Bool Source #
Eq (f p) => Eq ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: M1 i c f p -> M1 i c f p -> Bool Source # (/=) :: M1 i c f p -> M1 i c f p -> Bool Source #
Eq (f (g p)) => Eq ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # (/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source #
( Eq1 f, Eq1 g, Eq a) => Eq ( Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods (==) :: Compose f g a -> Compose f g a -> Bool Source # (/=) :: Compose f g a -> Compose f g a -> Bool Source #
Eq (p b a) => Eq ( Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods (==) :: Flip p a b -> Flip p a b -> Bool Source # (/=) :: Flip p a b -> Flip p a b -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # (/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source #
( Eq (p a b), Eq (q a b)) => Eq ( Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods (==) :: Sum p q a b -> Sum p q a b -> Bool Source # (/=) :: Sum p q a b -> Sum p q a b -> Bool Source #
( Eq (f a b), Eq (g a b)) => Eq ( Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods (==) :: Product f g a b -> Product f g a b -> Bool Source # (/=) :: Product f g a b -> Product f g a b -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # (/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source #
Eq (f (p a b)) => Eq ( Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods (==) :: Tannen f p a b -> Tannen f p a b -> Bool Source # (/=) :: Tannen f p a b -> Tannen f p a b -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source #
Eq (p (f a) (g b)) => Eq ( Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods (==) :: Biff p f g a b -> Biff p f g a b -> Bool Source # (/=) :: Biff p f g a b -> Biff p f g a b -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool Source #
( Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool Source # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool Source #

class Fractional a => Floating a where Source #

Trigonometric and hyperbolic functions and related functions.

The Haskell Report defines no laws for Floating . However, ( + ) , ( * ) and exp are customarily expected to define an exponential field and have the following properties:

exp (a + b) = exp a * exp b
exp (fromInteger 0) = fromInteger 1

Minimal complete definition

pi , exp , log , sin , cos , asin , acos , atan , sinh , cosh , asinh , acosh , atanh

Methods

pi :: a Source #

exp :: a -> a Source #

log :: a -> a Source #

sqrt :: a -> a Source #

(**) :: a -> a -> a infixr 8 Source #

logBase :: a -> a -> a Source #

sin :: a -> a Source #

cos :: a -> a Source #

tan :: a -> a Source #

asin :: a -> a Source #

acos :: a -> a Source #

atan :: a -> a Source #

sinh :: a -> a Source #

cosh :: a -> a Source #

tanh :: a -> a Source #

asinh :: a -> a Source #

acosh :: a -> a Source #

atanh :: a -> a Source #

log1p :: a -> a Source #

log1p x computes log (1 + x) , but provides more precise results for small (absolute) values of x if possible.

Since: base-4.9.0.0

expm1 :: a -> a Source #

expm1 x computes exp x - 1 , but provides more precise results for small (absolute) values of x if possible.

Since: base-4.9.0.0

log1pexp :: a -> a Source #

log1pexp x computes log (1 + exp x) , but provides more precise results if possible.

Examples:

if x is a large negative number, log (1 + exp x) will be imprecise for the reasons given in log1p .
if exp x is close to -1 , log (1 + exp x) will be imprecise for the reasons given in expm1 .

Since: base-4.9.0.0

log1mexp :: a -> a Source #

log1mexp x computes log (1 - exp x) , but provides more precise results if possible.

Examples:

if x is a large negative number, log (1 - exp x) will be imprecise for the reasons given in log1p .
if exp x is close to 1 , log (1 - exp x) will be imprecise for the reasons given in expm1 .

Since: base-4.9.0.0

Instances

Instances details

Floating Double	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double Source # exp :: Double -> Double Source # log :: Double -> Double Source # sqrt :: Double -> Double Source # (**) :: Double -> Double -> Double Source # logBase :: Double -> Double -> Double Source # sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # acosh :: Double -> Double Source # atanh :: Double -> Double Source # log1p :: Double -> Double Source # expm1 :: Double -> Double Source # log1pexp :: Double -> Double Source # log1mexp :: Double -> Double Source #
Floating Float	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float Source # exp :: Float -> Float Source # log :: Float -> Float Source # sqrt :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source # log1p :: Float -> Float Source # expm1 :: Float -> Float Source # log1pexp :: Float -> Float Source # log1mexp :: Float -> Float Source #
Floating CFloat
Instance details Defined in Foreign.C.Types Methods pi :: CFloat Source # exp :: CFloat -> CFloat Source # log :: CFloat -> CFloat Source # sqrt :: CFloat -> CFloat Source # (**) :: CFloat -> CFloat -> CFloat Source # logBase :: CFloat -> CFloat -> CFloat Source # sin :: CFloat -> CFloat Source # cos :: CFloat -> CFloat Source # tan :: CFloat -> CFloat Source # asin :: CFloat -> CFloat Source # acos :: CFloat -> CFloat Source # atan :: CFloat -> CFloat Source # sinh :: CFloat -> CFloat Source # cosh :: CFloat -> CFloat Source # tanh :: CFloat -> CFloat Source # asinh :: CFloat -> CFloat Source # acosh :: CFloat -> CFloat Source # atanh :: CFloat -> CFloat Source # log1p :: CFloat -> CFloat Source # expm1 :: CFloat -> CFloat Source # log1pexp :: CFloat -> CFloat Source # log1mexp :: CFloat -> CFloat Source #
Floating CDouble
Instance details Defined in Foreign.C.Types Methods pi :: CDouble Source # exp :: CDouble -> CDouble Source # log :: CDouble -> CDouble Source # sqrt :: CDouble -> CDouble Source # (**) :: CDouble -> CDouble -> CDouble Source # logBase :: CDouble -> CDouble -> CDouble Source # sin :: CDouble -> CDouble Source # cos :: CDouble -> CDouble Source # tan :: CDouble -> CDouble Source # asin :: CDouble -> CDouble Source # acos :: CDouble -> CDouble Source # atan :: CDouble -> CDouble Source # sinh :: CDouble -> CDouble Source # cosh :: CDouble -> CDouble Source # tanh :: CDouble -> CDouble Source # asinh :: CDouble -> CDouble Source # acosh :: CDouble -> CDouble Source # atanh :: CDouble -> CDouble Source # log1p :: CDouble -> CDouble Source # expm1 :: CDouble -> CDouble Source # log1pexp :: CDouble -> CDouble Source # log1mexp :: CDouble -> CDouble Source #
RealFloat a => Floating ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods pi :: Complex a Source # exp :: Complex a -> Complex a Source # log :: Complex a -> Complex a Source # sqrt :: Complex a -> Complex a Source # (**) :: Complex a -> Complex a -> Complex a Source # logBase :: Complex a -> Complex a -> Complex a Source # sin :: Complex a -> Complex a Source # cos :: Complex a -> Complex a Source # tan :: Complex a -> Complex a Source # asin :: Complex a -> Complex a Source # acos :: Complex a -> Complex a Source # atan :: Complex a -> Complex a Source # sinh :: Complex a -> Complex a Source # cosh :: Complex a -> Complex a Source # tanh :: Complex a -> Complex a Source # asinh :: Complex a -> Complex a Source # acosh :: Complex a -> Complex a Source # atanh :: Complex a -> Complex a Source # log1p :: Complex a -> Complex a Source # expm1 :: Complex a -> Complex a Source # log1pexp :: Complex a -> Complex a Source # log1mexp :: Complex a -> Complex a Source #
Floating a => Floating ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a Source # exp :: Identity a -> Identity a Source # log :: Identity a -> Identity a Source # sqrt :: Identity a -> Identity a Source # (**) :: Identity a -> Identity a -> Identity a Source # logBase :: Identity a -> Identity a -> Identity a Source # sin :: Identity a -> Identity a Source # cos :: Identity a -> Identity a Source # tan :: Identity a -> Identity a Source # asin :: Identity a -> Identity a Source # acos :: Identity a -> Identity a Source # atan :: Identity a -> Identity a Source # sinh :: Identity a -> Identity a Source # cosh :: Identity a -> Identity a Source # tanh :: Identity a -> Identity a Source # asinh :: Identity a -> Identity a Source # acosh :: Identity a -> Identity a Source # atanh :: Identity a -> Identity a Source # log1p :: Identity a -> Identity a Source # expm1 :: Identity a -> Identity a Source # log1pexp :: Identity a -> Identity a Source # log1mexp :: Identity a -> Identity a Source #
Floating a => Floating ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods pi :: Down a Source # exp :: Down a -> Down a Source # log :: Down a -> Down a Source # sqrt :: Down a -> Down a Source # (**) :: Down a -> Down a -> Down a Source # logBase :: Down a -> Down a -> Down a Source # sin :: Down a -> Down a Source # cos :: Down a -> Down a Source # tan :: Down a -> Down a Source # asin :: Down a -> Down a Source # acos :: Down a -> Down a Source # atan :: Down a -> Down a Source # sinh :: Down a -> Down a Source # cosh :: Down a -> Down a Source # tanh :: Down a -> Down a Source # asinh :: Down a -> Down a Source # acosh :: Down a -> Down a Source # atanh :: Down a -> Down a Source # log1p :: Down a -> Down a Source # expm1 :: Down a -> Down a Source # log1pexp :: Down a -> Down a Source # log1mexp :: Down a -> Down a Source #
Floating a => Floating ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods pi :: Shown a Source # exp :: Shown a -> Shown a Source # log :: Shown a -> Shown a Source # sqrt :: Shown a -> Shown a Source # (**) :: Shown a -> Shown a -> Shown a Source # logBase :: Shown a -> Shown a -> Shown a Source # sin :: Shown a -> Shown a Source # cos :: Shown a -> Shown a Source # tan :: Shown a -> Shown a Source # asin :: Shown a -> Shown a Source # acos :: Shown a -> Shown a Source # atan :: Shown a -> Shown a Source # sinh :: Shown a -> Shown a Source # cosh :: Shown a -> Shown a Source # tanh :: Shown a -> Shown a Source # asinh :: Shown a -> Shown a Source # acosh :: Shown a -> Shown a Source # atanh :: Shown a -> Shown a Source # log1p :: Shown a -> Shown a Source # expm1 :: Shown a -> Shown a Source # log1pexp :: Shown a -> Shown a Source # log1mexp :: Shown a -> Shown a Source #
Floating a => Floating ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods pi :: Const a b Source # exp :: Const a b -> Const a b Source # log :: Const a b -> Const a b Source # sqrt :: Const a b -> Const a b Source # (**) :: Const a b -> Const a b -> Const a b Source # logBase :: Const a b -> Const a b -> Const a b Source # sin :: Const a b -> Const a b Source # cos :: Const a b -> Const a b Source # tan :: Const a b -> Const a b Source # asin :: Const a b -> Const a b Source # acos :: Const a b -> Const a b Source # atan :: Const a b -> Const a b Source # sinh :: Const a b -> Const a b Source # cosh :: Const a b -> Const a b Source # tanh :: Const a b -> Const a b Source # asinh :: Const a b -> Const a b Source # acosh :: Const a b -> Const a b Source # atanh :: Const a b -> Const a b Source # log1p :: Const a b -> Const a b Source # expm1 :: Const a b -> Const a b Source # log1pexp :: Const a b -> Const a b Source # log1mexp :: Const a b -> Const a b Source #
Floating a => Floating ( Tagged s a)
Instance details Defined in Data.Tagged Methods pi :: Tagged s a Source # exp :: Tagged s a -> Tagged s a Source # log :: Tagged s a -> Tagged s a Source # sqrt :: Tagged s a -> Tagged s a Source # (**) :: Tagged s a -> Tagged s a -> Tagged s a Source # logBase :: Tagged s a -> Tagged s a -> Tagged s a Source # sin :: Tagged s a -> Tagged s a Source # cos :: Tagged s a -> Tagged s a Source # tan :: Tagged s a -> Tagged s a Source # asin :: Tagged s a -> Tagged s a Source # acos :: Tagged s a -> Tagged s a Source # atan :: Tagged s a -> Tagged s a Source # sinh :: Tagged s a -> Tagged s a Source # cosh :: Tagged s a -> Tagged s a Source # tanh :: Tagged s a -> Tagged s a Source # asinh :: Tagged s a -> Tagged s a Source # acosh :: Tagged s a -> Tagged s a Source # atanh :: Tagged s a -> Tagged s a Source # log1p :: Tagged s a -> Tagged s a Source # expm1 :: Tagged s a -> Tagged s a Source # log1pexp :: Tagged s a -> Tagged s a Source # log1mexp :: Tagged s a -> Tagged s a Source #

class Num a => Fractional a where Source #

Fractional numbers, supporting real division.

The Haskell Report defines no laws for Fractional . However, ( + ) and ( * ) are customarily expected to define a division ring and have the following properties:

recip gives the multiplicative inverse: x * recip x = recip x * x = fromInteger 1

Note that it isn't customarily expected that a type instance of Fractional implement a field. However, all instances in base do.

Minimal complete definition

fromRational , ( recip | (/) )

Methods

(/) :: a -> a -> a infixl 7 Source #

Fractional division.

recip :: a -> a Source #

Reciprocal fraction.

fromRational :: Rational -> a Source #

Conversion from a Rational (that is Ratio Integer ). A floating literal stands for an application of fromRational to a value of type Rational , so such literals have type ( Fractional a) => a .

Instances

Instances details

Fractional Scientific	WARNING: `recip` and `/` will throw an error when their outputs are repeating decimals . These methods also compute `Integer` magnitudes ( `10^e` ). If these methods are applied to arguments which have huge exponents this could fill up all space and crash your program! So don't apply these methods to scientific numbers coming from untrusted sources. `fromRational` will throw an error when the input `Rational` is a repeating decimal. Consider using `fromRationalRepetend` for these rationals which will detect the repetition and indicate where it starts.
Instance details Defined in Data.Scientific Methods (/) :: Scientific -> Scientific -> Scientific Source # recip :: Scientific -> Scientific Source # fromRational :: Rational -> Scientific Source #
Fractional CFloat
Instance details Defined in Foreign.C.Types Methods (/) :: CFloat -> CFloat -> CFloat Source # recip :: CFloat -> CFloat Source # fromRational :: Rational -> CFloat Source #
Fractional CDouble
Instance details Defined in Foreign.C.Types Methods (/) :: CDouble -> CDouble -> CDouble Source # recip :: CDouble -> CDouble Source # fromRational :: Rational -> CDouble Source #
Fractional DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods (/) :: DiffTime -> DiffTime -> DiffTime Source # recip :: DiffTime -> DiffTime Source # fromRational :: Rational -> DiffTime Source #
Fractional NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (/) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime Source # recip :: NominalDiffTime -> NominalDiffTime Source # fromRational :: Rational -> NominalDiffTime Source #
Integral a => Fractional ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (/) :: Ratio a -> Ratio a -> Ratio a Source # recip :: Ratio a -> Ratio a Source # fromRational :: Rational -> Ratio a Source #
RealFloat a => Fractional ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (/) :: Complex a -> Complex a -> Complex a Source # recip :: Complex a -> Complex a Source # fromRational :: Rational -> Complex a Source #
Fractional a => Fractional ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a Source # recip :: Identity a -> Identity a Source # fromRational :: Rational -> Identity a Source #
Fractional a => Fractional ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (/) :: Down a -> Down a -> Down a Source # recip :: Down a -> Down a Source # fromRational :: Rational -> Down a Source #
Fractional a => Fractional ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods (/) :: Shown a -> Shown a -> Shown a Source # recip :: Shown a -> Shown a Source # fromRational :: Rational -> Shown a Source #
HasResolution a => Fractional ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (/) :: Fixed a -> Fixed a -> Fixed a Source # recip :: Fixed a -> Fixed a Source # fromRational :: Rational -> Fixed a Source #
Fractional a => Fractional ( 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 Source # recip :: Const a b -> Const a b Source # fromRational :: Rational -> Const a b Source #
Fractional a => Fractional ( Tagged s a)
Instance details Defined in Data.Tagged Methods (/) :: Tagged s a -> Tagged s a -> Tagged s a Source # recip :: Tagged s a -> Tagged s a Source # fromRational :: Rational -> Tagged s a Source #

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

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 .

Minimal complete definition

quotRem , toInteger

Methods

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

integer division truncated toward zero

rem :: a -> a -> a infixl 7 Source #

integer remainder, satisfying

(x `quot` y)*y + (x `rem` y) == x

div :: a -> a -> a infixl 7 Source #

integer division truncated toward negative infinity

mod :: a -> a -> a infixl 7 Source #

integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

quotRem :: a -> a -> (a, a) Source #

simultaneous quot and rem

divMod :: a -> a -> (a, a) Source #

simultaneous div and mod

toInteger :: a -> Integer Source #

conversion to Integer

Instances

Instances details

Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Int -> Int -> Int Source # rem :: Int -> Int -> Int Source # div :: Int -> Int -> Int Source # mod :: Int -> Int -> Int Source # quotRem :: Int -> Int -> ( Int , Int ) Source # divMod :: Int -> Int -> ( Int , Int ) Source # toInteger :: Int -> Integer Source #
Integral Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int8 -> Int8 -> Int8 Source # rem :: Int8 -> Int8 -> Int8 Source # div :: Int8 -> Int8 -> Int8 Source # mod :: Int8 -> Int8 -> Int8 Source # quotRem :: Int8 -> Int8 -> ( Int8 , Int8 ) Source # divMod :: Int8 -> Int8 -> ( Int8 , Int8 ) Source # toInteger :: Int8 -> Integer Source #
Integral Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int16 -> Int16 -> Int16 Source # rem :: Int16 -> Int16 -> Int16 Source # div :: Int16 -> Int16 -> Int16 Source # mod :: Int16 -> Int16 -> Int16 Source # quotRem :: Int16 -> Int16 -> ( Int16 , Int16 ) Source # divMod :: Int16 -> Int16 -> ( Int16 , Int16 ) Source # toInteger :: Int16 -> Integer Source #
Integral Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int32 -> Int32 -> Int32 Source # rem :: Int32 -> Int32 -> Int32 Source # div :: Int32 -> Int32 -> Int32 Source # mod :: Int32 -> Int32 -> Int32 Source # quotRem :: Int32 -> Int32 -> ( Int32 , Int32 ) Source # divMod :: Int32 -> Int32 -> ( Int32 , Int32 ) Source # toInteger :: Int32 -> Integer Source #
Integral Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int64 -> Int64 -> Int64 Source # rem :: Int64 -> Int64 -> Int64 Source # div :: Int64 -> Int64 -> Int64 Source # mod :: Int64 -> Int64 -> Int64 Source # quotRem :: Int64 -> Int64 -> ( Int64 , Int64 ) Source # divMod :: Int64 -> Int64 -> ( Int64 , Int64 ) Source # toInteger :: Int64 -> Integer Source #
Integral Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Integer -> Integer -> Integer Source # rem :: Integer -> Integer -> Integer Source # div :: Integer -> Integer -> Integer Source # mod :: Integer -> Integer -> Integer Source # quotRem :: Integer -> Integer -> ( Integer , Integer ) Source # divMod :: Integer -> Integer -> ( Integer , Integer ) Source # toInteger :: Integer -> Integer Source #
Integral Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural Source # rem :: Natural -> Natural -> Natural Source # div :: Natural -> Natural -> Natural Source # mod :: Natural -> Natural -> Natural Source # quotRem :: Natural -> Natural -> ( Natural , Natural ) Source # divMod :: Natural -> Natural -> ( Natural , Natural ) Source # toInteger :: Natural -> Integer Source #
Integral Word	Since: base-2.1
Instance details Defined in GHC.Real Methods quot :: Word -> Word -> Word Source # rem :: Word -> Word -> Word Source # div :: Word -> Word -> Word Source # mod :: Word -> Word -> Word Source # quotRem :: Word -> Word -> ( Word , Word ) Source # divMod :: Word -> Word -> ( Word , Word ) Source # toInteger :: Word -> Integer Source #
Integral Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word8 -> Word8 -> Word8 Source # rem :: Word8 -> Word8 -> Word8 Source # div :: Word8 -> Word8 -> Word8 Source # mod :: Word8 -> Word8 -> Word8 Source # quotRem :: Word8 -> Word8 -> ( Word8 , Word8 ) Source # divMod :: Word8 -> Word8 -> ( Word8 , Word8 ) Source # toInteger :: Word8 -> Integer Source #
Integral Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word16 -> Word16 -> Word16 Source # rem :: Word16 -> Word16 -> Word16 Source # div :: Word16 -> Word16 -> Word16 Source # mod :: Word16 -> Word16 -> Word16 Source # quotRem :: Word16 -> Word16 -> ( Word16 , Word16 ) Source # divMod :: Word16 -> Word16 -> ( Word16 , Word16 ) Source # toInteger :: Word16 -> Integer Source #
Integral Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word32 -> Word32 -> Word32 Source # rem :: Word32 -> Word32 -> Word32 Source # div :: Word32 -> Word32 -> Word32 Source # mod :: Word32 -> Word32 -> Word32 Source # quotRem :: Word32 -> Word32 -> ( Word32 , Word32 ) Source # divMod :: Word32 -> Word32 -> ( Word32 , Word32 ) Source # toInteger :: Word32 -> Integer Source #
Integral Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word64 -> Word64 -> Word64 Source # rem :: Word64 -> Word64 -> Word64 Source # div :: Word64 -> Word64 -> Word64 Source # mod :: Word64 -> Word64 -> Word64 Source # quotRem :: Word64 -> Word64 -> ( Word64 , Word64 ) Source # divMod :: Word64 -> Word64 -> ( Word64 , Word64 ) Source # toInteger :: Word64 -> Integer Source #
Integral CDev
Instance details Defined in System.Posix.Types Methods quot :: CDev -> CDev -> CDev Source # rem :: CDev -> CDev -> CDev Source # div :: CDev -> CDev -> CDev Source # mod :: CDev -> CDev -> CDev Source # quotRem :: CDev -> CDev -> ( CDev , CDev ) Source # divMod :: CDev -> CDev -> ( CDev , CDev ) Source # toInteger :: CDev -> Integer Source #
Integral CIno
Instance details Defined in System.Posix.Types Methods quot :: CIno -> CIno -> CIno Source # rem :: CIno -> CIno -> CIno Source # div :: CIno -> CIno -> CIno Source # mod :: CIno -> CIno -> CIno Source # quotRem :: CIno -> CIno -> ( CIno , CIno ) Source # divMod :: CIno -> CIno -> ( CIno , CIno ) Source # toInteger :: CIno -> Integer Source #
Integral CMode
Instance details Defined in System.Posix.Types Methods quot :: CMode -> CMode -> CMode Source # rem :: CMode -> CMode -> CMode Source # div :: CMode -> CMode -> CMode Source # mod :: CMode -> CMode -> CMode Source # quotRem :: CMode -> CMode -> ( CMode , CMode ) Source # divMod :: CMode -> CMode -> ( CMode , CMode ) Source # toInteger :: CMode -> Integer Source #
Integral COff
Instance details Defined in System.Posix.Types Methods quot :: COff -> COff -> COff Source # rem :: COff -> COff -> COff Source # div :: COff -> COff -> COff Source # mod :: COff -> COff -> COff Source # quotRem :: COff -> COff -> ( COff , COff ) Source # divMod :: COff -> COff -> ( COff , COff ) Source # toInteger :: COff -> Integer Source #
Integral CPid
Instance details Defined in System.Posix.Types Methods quot :: CPid -> CPid -> CPid Source # rem :: CPid -> CPid -> CPid Source # div :: CPid -> CPid -> CPid Source # mod :: CPid -> CPid -> CPid Source # quotRem :: CPid -> CPid -> ( CPid , CPid ) Source # divMod :: CPid -> CPid -> ( CPid , CPid ) Source # toInteger :: CPid -> Integer Source #
Integral CSsize
Instance details Defined in System.Posix.Types Methods quot :: CSsize -> CSsize -> CSsize Source # rem :: CSsize -> CSsize -> CSsize Source # div :: CSsize -> CSsize -> CSsize Source # mod :: CSsize -> CSsize -> CSsize Source # quotRem :: CSsize -> CSsize -> ( CSsize , CSsize ) Source # divMod :: CSsize -> CSsize -> ( CSsize , CSsize ) Source # toInteger :: CSsize -> Integer Source #
Integral CGid
Instance details Defined in System.Posix.Types Methods quot :: CGid -> CGid -> CGid Source # rem :: CGid -> CGid -> CGid Source # div :: CGid -> CGid -> CGid Source # mod :: CGid -> CGid -> CGid Source # quotRem :: CGid -> CGid -> ( CGid , CGid ) Source # divMod :: CGid -> CGid -> ( CGid , CGid ) Source # toInteger :: CGid -> Integer Source #
Integral CNlink
Instance details Defined in System.Posix.Types Methods quot :: CNlink -> CNlink -> CNlink Source # rem :: CNlink -> CNlink -> CNlink Source # div :: CNlink -> CNlink -> CNlink Source # mod :: CNlink -> CNlink -> CNlink Source # quotRem :: CNlink -> CNlink -> ( CNlink , CNlink ) Source # divMod :: CNlink -> CNlink -> ( CNlink , CNlink ) Source # toInteger :: CNlink -> Integer Source #
Integral CUid
Instance details Defined in System.Posix.Types Methods quot :: CUid -> CUid -> CUid Source # rem :: CUid -> CUid -> CUid Source # div :: CUid -> CUid -> CUid Source # mod :: CUid -> CUid -> CUid Source # quotRem :: CUid -> CUid -> ( CUid , CUid ) Source # divMod :: CUid -> CUid -> ( CUid , CUid ) Source # toInteger :: CUid -> Integer Source #
Integral CTcflag
Instance details Defined in System.Posix.Types Methods quot :: CTcflag -> CTcflag -> CTcflag Source # rem :: CTcflag -> CTcflag -> CTcflag Source # div :: CTcflag -> CTcflag -> CTcflag Source # mod :: CTcflag -> CTcflag -> CTcflag Source # quotRem :: CTcflag -> CTcflag -> ( CTcflag , CTcflag ) Source # divMod :: CTcflag -> CTcflag -> ( CTcflag , CTcflag ) Source # toInteger :: CTcflag -> Integer Source #
Integral CRLim
Instance details Defined in System.Posix.Types Methods quot :: CRLim -> CRLim -> CRLim Source # rem :: CRLim -> CRLim -> CRLim Source # div :: CRLim -> CRLim -> CRLim Source # mod :: CRLim -> CRLim -> CRLim Source # quotRem :: CRLim -> CRLim -> ( CRLim , CRLim ) Source # divMod :: CRLim -> CRLim -> ( CRLim , CRLim ) Source # toInteger :: CRLim -> Integer Source #
Integral CBlkSize
Instance details Defined in System.Posix.Types Methods quot :: CBlkSize -> CBlkSize -> CBlkSize Source # rem :: CBlkSize -> CBlkSize -> CBlkSize Source # div :: CBlkSize -> CBlkSize -> CBlkSize Source # mod :: CBlkSize -> CBlkSize -> CBlkSize Source # quotRem :: CBlkSize -> CBlkSize -> ( CBlkSize , CBlkSize ) Source # divMod :: CBlkSize -> CBlkSize -> ( CBlkSize , CBlkSize ) Source # toInteger :: CBlkSize -> Integer Source #
Integral CBlkCnt
Instance details Defined in System.Posix.Types Methods quot :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # rem :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # div :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # mod :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # quotRem :: CBlkCnt -> CBlkCnt -> ( CBlkCnt , CBlkCnt ) Source # divMod :: CBlkCnt -> CBlkCnt -> ( CBlkCnt , CBlkCnt ) Source # toInteger :: CBlkCnt -> Integer Source #
Integral CClockId
Instance details Defined in System.Posix.Types Methods quot :: CClockId -> CClockId -> CClockId Source # rem :: CClockId -> CClockId -> CClockId Source # div :: CClockId -> CClockId -> CClockId Source # mod :: CClockId -> CClockId -> CClockId Source # quotRem :: CClockId -> CClockId -> ( CClockId , CClockId ) Source # divMod :: CClockId -> CClockId -> ( CClockId , CClockId ) Source # toInteger :: CClockId -> Integer Source #
Integral CFsBlkCnt
Instance details Defined in System.Posix.Types Methods quot :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # rem :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # div :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # mod :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # quotRem :: CFsBlkCnt -> CFsBlkCnt -> ( CFsBlkCnt , CFsBlkCnt ) Source # divMod :: CFsBlkCnt -> CFsBlkCnt -> ( CFsBlkCnt , CFsBlkCnt ) Source # toInteger :: CFsBlkCnt -> Integer Source #
Integral CFsFilCnt
Instance details Defined in System.Posix.Types Methods quot :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # rem :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # div :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # mod :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # quotRem :: CFsFilCnt -> CFsFilCnt -> ( CFsFilCnt , CFsFilCnt ) Source # divMod :: CFsFilCnt -> CFsFilCnt -> ( CFsFilCnt , CFsFilCnt ) Source # toInteger :: CFsFilCnt -> Integer Source #
Integral CId
Instance details Defined in System.Posix.Types Methods quot :: CId -> CId -> CId Source # rem :: CId -> CId -> CId Source # div :: CId -> CId -> CId Source # mod :: CId -> CId -> CId Source # quotRem :: CId -> CId -> ( CId , CId ) Source # divMod :: CId -> CId -> ( CId , CId ) Source # toInteger :: CId -> Integer Source #
Integral CKey
Instance details Defined in System.Posix.Types Methods quot :: CKey -> CKey -> CKey Source # rem :: CKey -> CKey -> CKey Source # div :: CKey -> CKey -> CKey Source # mod :: CKey -> CKey -> CKey Source # quotRem :: CKey -> CKey -> ( CKey , CKey ) Source # divMod :: CKey -> CKey -> ( CKey , CKey ) Source # toInteger :: CKey -> Integer Source #
Integral CSocklen
Instance details Defined in System.Posix.Types Methods quot :: CSocklen -> CSocklen -> CSocklen Source # rem :: CSocklen -> CSocklen -> CSocklen Source # div :: CSocklen -> CSocklen -> CSocklen Source # mod :: CSocklen -> CSocklen -> CSocklen Source # quotRem :: CSocklen -> CSocklen -> ( CSocklen , CSocklen ) Source # divMod :: CSocklen -> CSocklen -> ( CSocklen , CSocklen ) Source # toInteger :: CSocklen -> Integer Source #
Integral CNfds
Instance details Defined in System.Posix.Types Methods quot :: CNfds -> CNfds -> CNfds Source # rem :: CNfds -> CNfds -> CNfds Source # div :: CNfds -> CNfds -> CNfds Source # mod :: CNfds -> CNfds -> CNfds Source # quotRem :: CNfds -> CNfds -> ( CNfds , CNfds ) Source # divMod :: CNfds -> CNfds -> ( CNfds , CNfds ) Source # toInteger :: CNfds -> Integer Source #
Integral Fd
Instance details Defined in System.Posix.Types Methods quot :: Fd -> Fd -> Fd Source # rem :: Fd -> Fd -> Fd Source # div :: Fd -> Fd -> Fd Source # mod :: Fd -> Fd -> Fd Source # quotRem :: Fd -> Fd -> ( Fd , Fd ) Source # divMod :: Fd -> Fd -> ( Fd , Fd ) Source # toInteger :: Fd -> Integer Source #
Integral CChar
Instance details Defined in Foreign.C.Types Methods quot :: CChar -> CChar -> CChar Source # rem :: CChar -> CChar -> CChar Source # div :: CChar -> CChar -> CChar Source # mod :: CChar -> CChar -> CChar Source # quotRem :: CChar -> CChar -> ( CChar , CChar ) Source # divMod :: CChar -> CChar -> ( CChar , CChar ) Source # toInteger :: CChar -> Integer Source #
Integral CSChar
Instance details Defined in Foreign.C.Types Methods quot :: CSChar -> CSChar -> CSChar Source # rem :: CSChar -> CSChar -> CSChar Source # div :: CSChar -> CSChar -> CSChar Source # mod :: CSChar -> CSChar -> CSChar Source # quotRem :: CSChar -> CSChar -> ( CSChar , CSChar ) Source # divMod :: CSChar -> CSChar -> ( CSChar , CSChar ) Source # toInteger :: CSChar -> Integer Source #
Integral CUChar
Instance details Defined in Foreign.C.Types Methods quot :: CUChar -> CUChar -> CUChar Source # rem :: CUChar -> CUChar -> CUChar Source # div :: CUChar -> CUChar -> CUChar Source # mod :: CUChar -> CUChar -> CUChar Source # quotRem :: CUChar -> CUChar -> ( CUChar , CUChar ) Source # divMod :: CUChar -> CUChar -> ( CUChar , CUChar ) Source # toInteger :: CUChar -> Integer Source #
Integral CShort
Instance details Defined in Foreign.C.Types Methods quot :: CShort -> CShort -> CShort Source # rem :: CShort -> CShort -> CShort Source # div :: CShort -> CShort -> CShort Source # mod :: CShort -> CShort -> CShort Source # quotRem :: CShort -> CShort -> ( CShort , CShort ) Source # divMod :: CShort -> CShort -> ( CShort , CShort ) Source # toInteger :: CShort -> Integer Source #
Integral CUShort
Instance details Defined in Foreign.C.Types Methods quot :: CUShort -> CUShort -> CUShort Source # rem :: CUShort -> CUShort -> CUShort Source # div :: CUShort -> CUShort -> CUShort Source # mod :: CUShort -> CUShort -> CUShort Source # quotRem :: CUShort -> CUShort -> ( CUShort , CUShort ) Source # divMod :: CUShort -> CUShort -> ( CUShort , CUShort ) Source # toInteger :: CUShort -> Integer Source #
Integral CInt
Instance details Defined in Foreign.C.Types Methods quot :: CInt -> CInt -> CInt Source # rem :: CInt -> CInt -> CInt Source # div :: CInt -> CInt -> CInt Source # mod :: CInt -> CInt -> CInt Source # quotRem :: CInt -> CInt -> ( CInt , CInt ) Source # divMod :: CInt -> CInt -> ( CInt , CInt ) Source # toInteger :: CInt -> Integer Source #
Integral CUInt
Instance details Defined in Foreign.C.Types Methods quot :: CUInt -> CUInt -> CUInt Source # rem :: CUInt -> CUInt -> CUInt Source # div :: CUInt -> CUInt -> CUInt Source # mod :: CUInt -> CUInt -> CUInt Source # quotRem :: CUInt -> CUInt -> ( CUInt , CUInt ) Source # divMod :: CUInt -> CUInt -> ( CUInt , CUInt ) Source # toInteger :: CUInt -> Integer Source #
Integral CLong
Instance details Defined in Foreign.C.Types Methods quot :: CLong -> CLong -> CLong Source # rem :: CLong -> CLong -> CLong Source # div :: CLong -> CLong -> CLong Source # mod :: CLong -> CLong -> CLong Source # quotRem :: CLong -> CLong -> ( CLong , CLong ) Source # divMod :: CLong -> CLong -> ( CLong , CLong ) Source # toInteger :: CLong -> Integer Source #
Integral CULong
Instance details Defined in Foreign.C.Types Methods quot :: CULong -> CULong -> CULong Source # rem :: CULong -> CULong -> CULong Source # div :: CULong -> CULong -> CULong Source # mod :: CULong -> CULong -> CULong Source # quotRem :: CULong -> CULong -> ( CULong , CULong ) Source # divMod :: CULong -> CULong -> ( CULong , CULong ) Source # toInteger :: CULong -> Integer Source #
Integral CLLong
Instance details Defined in Foreign.C.Types Methods quot :: CLLong -> CLLong -> CLLong Source # rem :: CLLong -> CLLong -> CLLong Source # div :: CLLong -> CLLong -> CLLong Source # mod :: CLLong -> CLLong -> CLLong Source # quotRem :: CLLong -> CLLong -> ( CLLong , CLLong ) Source # divMod :: CLLong -> CLLong -> ( CLLong , CLLong ) Source # toInteger :: CLLong -> Integer Source #
Integral CULLong
Instance details Defined in Foreign.C.Types Methods quot :: CULLong -> CULLong -> CULLong Source # rem :: CULLong -> CULLong -> CULLong Source # div :: CULLong -> CULLong -> CULLong Source # mod :: CULLong -> CULLong -> CULLong Source # quotRem :: CULLong -> CULLong -> ( CULLong , CULLong ) Source # divMod :: CULLong -> CULLong -> ( CULLong , CULLong ) Source # toInteger :: CULLong -> Integer Source #
Integral CBool
Instance details Defined in Foreign.C.Types Methods quot :: CBool -> CBool -> CBool Source # rem :: CBool -> CBool -> CBool Source # div :: CBool -> CBool -> CBool Source # mod :: CBool -> CBool -> CBool Source # quotRem :: CBool -> CBool -> ( CBool , CBool ) Source # divMod :: CBool -> CBool -> ( CBool , CBool ) Source # toInteger :: CBool -> Integer Source #
Integral CPtrdiff
Instance details Defined in Foreign.C.Types Methods quot :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # rem :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # div :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # mod :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # quotRem :: CPtrdiff -> CPtrdiff -> ( CPtrdiff , CPtrdiff ) Source # divMod :: CPtrdiff -> CPtrdiff -> ( CPtrdiff , CPtrdiff ) Source # toInteger :: CPtrdiff -> Integer Source #
Integral CSize
Instance details Defined in Foreign.C.Types Methods quot :: CSize -> CSize -> CSize Source # rem :: CSize -> CSize -> CSize Source # div :: CSize -> CSize -> CSize Source # mod :: CSize -> CSize -> CSize Source # quotRem :: CSize -> CSize -> ( CSize , CSize ) Source # divMod :: CSize -> CSize -> ( CSize , CSize ) Source # toInteger :: CSize -> Integer Source #
Integral CWchar
Instance details Defined in Foreign.C.Types Methods quot :: CWchar -> CWchar -> CWchar Source # rem :: CWchar -> CWchar -> CWchar Source # div :: CWchar -> CWchar -> CWchar Source # mod :: CWchar -> CWchar -> CWchar Source # quotRem :: CWchar -> CWchar -> ( CWchar , CWchar ) Source # divMod :: CWchar -> CWchar -> ( CWchar , CWchar ) Source # toInteger :: CWchar -> Integer Source #
Integral CSigAtomic
Instance details Defined in Foreign.C.Types Methods quot :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # rem :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # div :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # mod :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # quotRem :: CSigAtomic -> CSigAtomic -> ( CSigAtomic , CSigAtomic ) Source # divMod :: CSigAtomic -> CSigAtomic -> ( CSigAtomic , CSigAtomic ) Source # toInteger :: CSigAtomic -> Integer Source #
Integral CIntPtr
Instance details Defined in Foreign.C.Types Methods quot :: CIntPtr -> CIntPtr -> CIntPtr Source # rem :: CIntPtr -> CIntPtr -> CIntPtr Source # div :: CIntPtr -> CIntPtr -> CIntPtr Source # mod :: CIntPtr -> CIntPtr -> CIntPtr Source # quotRem :: CIntPtr -> CIntPtr -> ( CIntPtr , CIntPtr ) Source # divMod :: CIntPtr -> CIntPtr -> ( CIntPtr , CIntPtr ) Source # toInteger :: CIntPtr -> Integer Source #
Integral CUIntPtr
Instance details Defined in Foreign.C.Types Methods quot :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # rem :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # div :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # mod :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # quotRem :: CUIntPtr -> CUIntPtr -> ( CUIntPtr , CUIntPtr ) Source # divMod :: CUIntPtr -> CUIntPtr -> ( CUIntPtr , CUIntPtr ) Source # toInteger :: CUIntPtr -> Integer Source #
Integral CIntMax
Instance details Defined in Foreign.C.Types Methods quot :: CIntMax -> CIntMax -> CIntMax Source # rem :: CIntMax -> CIntMax -> CIntMax Source # div :: CIntMax -> CIntMax -> CIntMax Source # mod :: CIntMax -> CIntMax -> CIntMax Source # quotRem :: CIntMax -> CIntMax -> ( CIntMax , CIntMax ) Source # divMod :: CIntMax -> CIntMax -> ( CIntMax , CIntMax ) Source # toInteger :: CIntMax -> Integer Source #
Integral CUIntMax
Instance details Defined in Foreign.C.Types Methods quot :: CUIntMax -> CUIntMax -> CUIntMax Source # rem :: CUIntMax -> CUIntMax -> CUIntMax Source # div :: CUIntMax -> CUIntMax -> CUIntMax Source # mod :: CUIntMax -> CUIntMax -> CUIntMax Source # quotRem :: CUIntMax -> CUIntMax -> ( CUIntMax , CUIntMax ) Source # divMod :: CUIntMax -> CUIntMax -> ( CUIntMax , CUIntMax ) Source # toInteger :: CUIntMax -> Integer Source #
Integral WordPtr
Instance details Defined in Foreign.Ptr Methods quot :: WordPtr -> WordPtr -> WordPtr Source # rem :: WordPtr -> WordPtr -> WordPtr Source # div :: WordPtr -> WordPtr -> WordPtr Source # mod :: WordPtr -> WordPtr -> WordPtr Source # quotRem :: WordPtr -> WordPtr -> ( WordPtr , WordPtr ) Source # divMod :: WordPtr -> WordPtr -> ( WordPtr , WordPtr ) Source # toInteger :: WordPtr -> Integer Source #
Integral IntPtr
Instance details Defined in Foreign.Ptr Methods quot :: IntPtr -> IntPtr -> IntPtr Source # rem :: IntPtr -> IntPtr -> IntPtr Source # div :: IntPtr -> IntPtr -> IntPtr Source # mod :: IntPtr -> IntPtr -> IntPtr Source # quotRem :: IntPtr -> IntPtr -> ( IntPtr , IntPtr ) Source # divMod :: IntPtr -> IntPtr -> ( IntPtr , IntPtr ) Source # toInteger :: IntPtr -> Integer Source #
Integral Int54
Instance details Defined in Text.JSON.Canonical.Types Methods quot :: Int54 -> Int54 -> Int54 Source # rem :: Int54 -> Int54 -> Int54 Source # div :: Int54 -> Int54 -> Int54 Source # mod :: Int54 -> Int54 -> Int54 Source # quotRem :: Int54 -> Int54 -> ( Int54 , Int54 ) Source # divMod :: Int54 -> Int54 -> ( Int54 , Int54 ) Source # toInteger :: Int54 -> Integer Source #
Integral a => Integral ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a Source # rem :: Identity a -> Identity a -> Identity a Source # div :: Identity a -> Identity a -> Identity a Source # mod :: Identity a -> Identity a -> Identity a Source # quotRem :: Identity a -> Identity a -> ( Identity a, Identity a) Source # divMod :: Identity a -> Identity a -> ( Identity a, Identity a) Source # toInteger :: Identity a -> Integer Source #
Integral a => Integral ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods quot :: Down a -> Down a -> Down a Source # rem :: Down a -> Down a -> Down a Source # div :: Down a -> Down a -> Down a Source # mod :: Down a -> Down a -> Down a Source # quotRem :: Down a -> Down a -> ( Down a, Down a) Source # divMod :: Down a -> Down a -> ( Down a, Down a) Source # toInteger :: Down a -> Integer Source #
Integral a => Integral ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods quot :: Hex a -> Hex a -> Hex a Source # rem :: Hex a -> Hex a -> Hex a Source # div :: Hex a -> Hex a -> Hex a Source # mod :: Hex a -> Hex a -> Hex a Source # quotRem :: Hex a -> Hex a -> ( Hex a, Hex a) Source # divMod :: Hex a -> Hex a -> ( Hex a, Hex a) Source # toInteger :: Hex a -> Integer Source #
Integral a => Integral ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods quot :: Shown a -> Shown a -> Shown a Source # rem :: Shown a -> Shown a -> Shown a Source # div :: Shown a -> Shown a -> Shown a Source # mod :: Shown a -> Shown a -> Shown a Source # quotRem :: Shown a -> Shown a -> ( Shown a, Shown a) Source # divMod :: Shown a -> Shown a -> ( Shown a, Shown a) Source # toInteger :: Shown a -> Integer Source #
Integral a => Integral ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b Source # rem :: Const a b -> Const a b -> Const a b Source # div :: Const a b -> Const a b -> Const a b Source # mod :: Const a b -> Const a b -> Const a b Source # quotRem :: Const a b -> Const a b -> ( Const a b, Const a b) Source # divMod :: Const a b -> Const a b -> ( Const a b, Const a b) Source # toInteger :: Const a b -> Integer Source #
Integral a => Integral ( Tagged s a)
Instance details Defined in Data.Tagged Methods quot :: Tagged s a -> Tagged s a -> Tagged s a Source # rem :: Tagged s a -> Tagged s a -> Tagged s a Source # div :: Tagged s a -> Tagged s a -> Tagged s a Source # mod :: Tagged s a -> Tagged s a -> Tagged s a Source # quotRem :: Tagged s a -> Tagged s a -> ( Tagged s a, Tagged s a) Source # divMod :: Tagged s a -> Tagged s a -> ( Tagged s a, Tagged s a) Source # toInteger :: Tagged s a -> Integer Source #

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

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

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

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

Inject a value into the monadic type.

Instances

Instances details

Monad []	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] Source # (>>) :: [a] -> [b] -> [b] Source # return :: a -> [a] Source #
Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Source # (>>) :: Maybe a -> Maybe b -> Maybe b Source # return :: a -> Maybe a Source #
Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b Source # (>>) :: IO a -> IO b -> IO b Source # return :: a -> IO a Source #
Monad Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b Source # (>>) :: Par1 a -> Par1 b -> Par1 b Source # return :: a -> Par1 a Source #
Monad Q
Instance details Defined in Language.Haskell.TH.Syntax Methods (>>=) :: Q a -> (a -> Q b) -> Q b Source # (>>) :: Q a -> Q b -> Q b Source # return :: a -> Q a Source #
Monad Solo
Instance details Defined in Data.Tuple.Solo Methods (>>=) :: Solo a -> (a -> Solo b) -> Solo b Source # (>>) :: Solo a -> Solo b -> Solo b Source # return :: a -> Solo a Source #
Monad IResult
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: IResult a -> (a -> IResult b) -> IResult b Source # (>>) :: IResult a -> IResult b -> IResult b Source # return :: a -> IResult a Source #
Monad Result
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: Result a -> (a -> Result b) -> Result b Source # (>>) :: Result a -> Result b -> Result b Source # return :: a -> Result a Source #
Monad Parser
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: Parser a -> (a -> Parser b) -> Parser b Source # (>>) :: Parser a -> Parser b -> Parser b Source # return :: a -> Parser a Source #
Monad Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b Source # (>>) :: Complex a -> Complex b -> Complex b Source # return :: a -> Complex a Source #
Monad Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Min a -> (a -> Min b) -> Min b Source # (>>) :: Min a -> Min b -> Min b Source # return :: a -> Min a Source #
Monad Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Max a -> (a -> Max b) -> Max b Source # (>>) :: Max a -> Max b -> Max b Source # return :: a -> Max a Source #
Monad First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: First a -> (a -> First b) -> First b Source # (>>) :: First a -> First b -> First b Source # return :: a -> First a Source #
Monad Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Last a -> (a -> Last b) -> Last b Source # (>>) :: Last a -> Last b -> Last b Source # return :: a -> Last a Source #
Monad Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Option a -> (a -> Option b) -> Option b Source # (>>) :: Option a -> Option b -> Option b Source # return :: a -> Option a Source #
Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b Source # (>>) :: Identity a -> Identity b -> Identity b Source # return :: a -> Identity a Source #
Monad STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b Source # (>>) :: STM a -> STM b -> STM b Source # return :: a -> STM a Source #
Monad First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b Source # (>>) :: First a -> First b -> First b Source # return :: a -> First a Source #
Monad Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b Source # (>>) :: Last a -> Last b -> Last b Source # return :: a -> Last a Source #
Monad Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b Source # (>>) :: Dual a -> Dual b -> Dual b Source # return :: a -> Dual a Source #
Monad Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b Source # (>>) :: Sum a -> Sum b -> Sum b Source # return :: a -> Sum a Source #
Monad Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Product a -> (a -> Product b) -> Product b Source # (>>) :: Product a -> Product b -> Product b Source # return :: a -> Product a Source #
Monad Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b Source # (>>) :: Down a -> Down b -> Down b Source # return :: a -> Down a Source #
Monad ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b Source # (>>) :: ReadP a -> ReadP b -> ReadP b Source # return :: a -> ReadP a Source #
Monad NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b Source # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source # return :: a -> NonEmpty a Source #
Monad Tree
Instance details Defined in Data.Tree Methods (>>=) :: Tree a -> (a -> Tree b) -> Tree b Source # (>>) :: Tree a -> Tree b -> Tree b Source # return :: a -> Tree a Source #
Monad Seq
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b Source # (>>) :: Seq a -> Seq b -> Seq b Source # return :: a -> Seq a Source #
Monad DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods (>>=) :: DNonEmpty a -> (a -> DNonEmpty b) -> DNonEmpty b Source # (>>) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty b Source # return :: a -> DNonEmpty a Source #
Monad DList
Instance details Defined in Data.DList.Internal Methods (>>=) :: DList a -> (a -> DList b) -> DList b Source # (>>) :: DList a -> DList b -> DList b Source # return :: a -> DList a Source #
Monad SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods (>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b Source # (>>) :: SmallArray a -> SmallArray b -> SmallArray b Source # return :: a -> SmallArray a Source #
Monad Array
Instance details Defined in Data.Primitive.Array Methods (>>=) :: Array a -> (a -> Array b) -> Array b Source # (>>) :: Array a -> Array b -> Array b Source # return :: a -> Array a Source #
Monad Vector
Instance details Defined in Data.Vector Methods (>>=) :: Vector a -> (a -> Vector b) -> Vector b Source # (>>) :: Vector a -> Vector b -> Vector b Source # return :: a -> Vector a Source #
Monad P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: P a -> (a -> P b) -> P b Source # (>>) :: P a -> P b -> P b Source # return :: a -> P a Source #
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 Source # (>>) :: Either e a -> Either e b -> Either e b Source # return :: a -> Either e a Source #
Monad ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b Source # (>>) :: U1 a -> U1 b -> U1 b Source # return :: a -> U1 a Source #
Monoid a => Monad ( (,) a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) Source # (>>) :: (a, a0) -> (a, b) -> (a, b) Source # return :: a0 -> (a, a0) Source #
Monad ( ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b Source # (>>) :: ST s a -> ST s b -> ST s b Source # return :: a -> ST s a Source #
Monad ( Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods (>>=) :: Parser i a -> (a -> Parser i b) -> Parser i b Source # (>>) :: Parser i a -> Parser i b -> Parser i b Source # return :: a -> Parser i a Source #
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 Source # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # return :: a -> WrappedMonad m a Source #
ArrowApply a => Monad ( ArrowMonad a)	Since: base-2.1
Instance details Defined in Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b Source # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # return :: a0 -> ArrowMonad a a0 Source #
Monad ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b Source # (>>) :: Proxy a -> Proxy b -> Proxy b Source # return :: a -> Proxy a Source #
Monad ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods (>>=) :: Decoder s a -> (a -> Decoder s b) -> Decoder s b Source # (>>) :: Decoder s a -> Decoder s b -> Decoder s b Source # return :: a -> Decoder s a Source #
Monad m => Monad ( ListT m)
Instance details Defined in Control.Monad.Trans.List Methods (>>=) :: ListT m a -> (a -> ListT m b) -> ListT m b Source # (>>) :: ListT m a -> ListT m b -> ListT m b Source # return :: a -> ListT m a Source #
Semigroup a => Monad ( These a)
Instance details Defined in Data.These Methods (>>=) :: These a a0 -> (a0 -> These a b) -> These a b Source # (>>) :: These a a0 -> These a b -> These a b Source # return :: a0 -> These a a0 Source #
Semigroup a => Monad ( These a)
Instance details Defined in Data.Strict.These Methods (>>=) :: These a a0 -> (a0 -> These a b) -> These a b Source # (>>) :: These a a0 -> These a b -> These a b Source # return :: a0 -> These a a0 Source #
Monad m => Monad ( MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b Source # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b Source # return :: a -> MaybeT m a Source #
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 Source # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source # return :: a -> Rec1 f a Source #
( 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) Source # (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) Source # return :: a0 -> (a, b, a0) Source #
Monad m => Monad ( Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods (>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b Source # (>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b Source # return :: a0 -> Kleisli m a a0 Source #
Monad f => Monad ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b Source # (>>) :: Ap f a -> Ap f b -> Ap f b Source # return :: a -> Ap f a Source #
Monad f => Monad ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b Source # (>>) :: Alt f a -> Alt f b -> Alt f b Source # return :: a -> Alt f a Source #
Monad m => Monad ( IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods (>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b Source # (>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b Source # return :: a -> IdentityT m a Source #
( 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 Source # (>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b Source # return :: a -> WhenMissing f x a Source #
( Monad m, Error e) => Monad ( ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods (>>=) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b Source # (>>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b Source # return :: a -> ErrorT e m a Source #
Monad m => Monad ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b Source # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b Source # return :: a -> ExceptT e m a Source #
Monad m => Monad ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b Source # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b Source # return :: a -> ReaderT r m a Source #
Monad m => Monad ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b Source # (>>) :: StateT s m a -> StateT s m b -> StateT s m b Source # return :: a -> StateT s m a Source #
Monad m => Monad ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b Source # (>>) :: StateT s m a -> StateT s m b -> StateT s m b Source # return :: a -> StateT s m a Source #
( Monoid w, Monad m) => Monad ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b Source # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source # return :: a -> WriterT w m a Source #
( Monoid w, Monad m) => Monad ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b Source # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source # return :: a -> WriterT w m a Source #
Monad ( Tagged s)
Instance details Defined in Data.Tagged Methods (>>=) :: Tagged s a -> (a -> Tagged s b) -> Tagged s b Source # (>>) :: Tagged s a -> Tagged s b -> Tagged s b Source # return :: a -> Tagged s a Source #
Monad ((->) r :: Type -> Type )	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b Source # (>>) :: (r -> a) -> (r -> b) -> r -> b Source # return :: a -> r -> a Source #
( 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 Source # (>>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # return :: a -> (f :*: g) a Source #
( 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) Source # (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) Source # return :: a0 -> (a, b, c, a0) Source #
( Monad f, Monad g) => Monad ( Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods (>>=) :: Product f g a -> (a -> Product f g b) -> Product f g b Source # (>>) :: Product f g a -> Product f g b -> Product f g b Source # return :: a -> Product f g a Source #
( 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 Source # (>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b Source # return :: a -> WhenMatched f x y a Source #
( 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 Source # (>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b Source # return :: a -> WhenMissing f k x a Source #
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 Source # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source # return :: a -> M1 i c f a Source #
( 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 Source # (>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b Source # return :: a -> WhenMatched f k x y a Source #
( Monoid w, Monad m) => Monad ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b Source # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source # return :: a -> RWST r w s m a Source #
( Monoid w, Monad m) => Monad ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b Source # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source # return :: a -> RWST r w s m a Source #

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

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.

Minimal complete definition

fmap

Methods

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

Using ApplicativeDo : ' fmap f as ' can be understood as the do expression

do a <- as
   pure (f a)

with an inferred Functor constraint.

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

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.

Using ApplicativeDo : ' a <$ bs ' can be understood as the do expression

do bs
   pure a

with an inferred Functor constraint.

Instances

Instances details

Functor []	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> [a] -> [b] Source # (<$) :: a -> [b] -> [a] Source #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b Source # (<$) :: a -> Maybe b -> Maybe a Source #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b Source # (<$) :: a -> IO b -> IO a Source #
Functor Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b Source # (<$) :: a -> Par1 b -> Par1 a Source #
Functor Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> Q a -> Q b Source # (<$) :: a -> Q b -> Q a Source #
Functor Solo
Instance details Defined in Data.Tuple.Solo Methods fmap :: (a -> b) -> Solo a -> Solo b Source # (<$) :: a -> Solo b -> Solo a Source #
Functor IResult
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> IResult a -> IResult b Source # (<$) :: a -> IResult b -> IResult a Source #
Functor Result
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> Result a -> Result b Source # (<$) :: a -> Result b -> Result a Source #
Functor Parser
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> Parser a -> Parser b Source # (<$) :: a -> Parser b -> Parser a Source #
Functor KeyMap
Instance details Defined in Data.Aeson.KeyMap Methods fmap :: (a -> b) -> KeyMap a -> KeyMap b Source # (<$) :: a -> KeyMap b -> KeyMap a Source #
Functor Async
Instance details Defined in Control.Concurrent.Async Methods fmap :: (a -> b) -> Async a -> Async b Source # (<$) :: a -> Async b -> Async a Source #
Functor Concurrently
Instance details Defined in Control.Concurrent.Async Methods fmap :: (a -> b) -> Concurrently a -> Concurrently b Source # (<$) :: a -> Concurrently b -> Concurrently a Source #
Functor Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods fmap :: (a -> b) -> Complex a -> Complex b Source # (<$) :: a -> Complex b -> Complex a Source #
Functor Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Min a -> Min b Source # (<$) :: a -> Min b -> Min a Source #
Functor Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Max a -> Max b Source # (<$) :: a -> Max b -> Max a Source #
Functor First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> First a -> First b Source # (<$) :: a -> First b -> First a Source #
Functor Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Last a -> Last b Source # (<$) :: a -> Last b -> Last a Source #
Functor Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Option a -> Option b Source # (<$) :: a -> Option b -> Option a Source #
Functor ZipList	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b Source # (<$) :: a -> ZipList b -> ZipList a Source #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b Source # (<$) :: a -> Identity b -> Identity a Source #
Functor Handler	Since: base-4.6.0.0
Instance details Defined in Control.Exception Methods fmap :: (a -> b) -> Handler a -> Handler b Source # (<$) :: a -> Handler b -> Handler a Source #
Functor STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b Source # (<$) :: a -> STM b -> STM a Source #
Functor First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> First a -> First b Source # (<$) :: a -> First b -> First a Source #
Functor Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b Source # (<$) :: a -> Last b -> Last a Source #
Functor Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Dual a -> Dual b Source # (<$) :: a -> Dual b -> Dual a Source #
Functor Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Sum a -> Sum b Source # (<$) :: a -> Sum b -> Sum a Source #
Functor Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Product a -> Product b Source # (<$) :: a -> Product b -> Product a Source #
Functor Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b Source # (<$) :: a -> Down b -> Down a Source #
Functor ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> ReadP a -> ReadP b Source # (<$) :: a -> ReadP b -> ReadP a Source #
Functor NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b Source # (<$) :: a -> NonEmpty b -> NonEmpty a Source #
Functor IntMap
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> IntMap a -> IntMap b Source # (<$) :: a -> IntMap b -> IntMap a Source #
Functor Tree
Instance details Defined in Data.Tree Methods fmap :: (a -> b) -> Tree a -> Tree b Source # (<$) :: a -> Tree b -> Tree a Source #
Functor Seq
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b Source # (<$) :: a -> Seq b -> Seq a Source #
Functor FingerTree
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> FingerTree a -> FingerTree b Source # (<$) :: a -> FingerTree b -> FingerTree a Source #
Functor Digit
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Digit a -> Digit b Source # (<$) :: a -> Digit b -> Digit a Source #
Functor Node
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Node a -> Node b Source # (<$) :: a -> Node b -> Node a Source #
Functor Elem
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Elem a -> Elem b Source # (<$) :: a -> Elem b -> Elem a Source #
Functor ViewL
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewL a -> ViewL b Source # (<$) :: a -> ViewL b -> ViewL a Source #
Functor ViewR
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewR a -> ViewR b Source # (<$) :: a -> ViewR b -> ViewR a Source #
Functor DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods fmap :: (a -> b) -> DNonEmpty a -> DNonEmpty b Source # (<$) :: a -> DNonEmpty b -> DNonEmpty a Source #
Functor DList
Instance details Defined in Data.DList.Internal Methods fmap :: (a -> b) -> DList a -> DList b Source # (<$) :: a -> DList b -> DList a Source #
Functor GenClosure
Instance details Defined in GHC.Exts.Heap.Closures Methods fmap :: (a -> b) -> GenClosure a -> GenClosure b Source # (<$) :: a -> GenClosure b -> GenClosure a Source #
Functor Doc
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Doc a -> Doc b Source # (<$) :: a -> Doc b -> Doc a Source #
Functor AnnotDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b Source # (<$) :: a -> AnnotDetails b -> AnnotDetails a Source #
Functor Span
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Span a -> Span b Source # (<$) :: a -> Span b -> Span a Source #
Functor SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fmap :: (a -> b) -> SmallArray a -> SmallArray b Source # (<$) :: a -> SmallArray b -> SmallArray a Source #
Functor Array
Instance details Defined in Data.Primitive.Array Methods fmap :: (a -> b) -> Array a -> Array b Source # (<$) :: a -> Array b -> Array a Source #
Functor Maybe
Instance details Defined in Data.Strict.Maybe Methods fmap :: (a -> b) -> Maybe a -> Maybe b Source # (<$) :: a -> Maybe b -> Maybe a Source #
Functor Vector
Instance details Defined in Data.Vector Methods fmap :: (a -> b) -> Vector a -> Vector b Source # (<$) :: a -> Vector b -> Vector a Source #
Functor P	Since: base-4.8.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> P a -> P b Source # (<$) :: a -> P b -> P a Source #
Functor ( Either a)	Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b Source # (<$) :: a0 -> Either a b -> Either a a0 Source #
Functor ( V1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b Source # (<$) :: a -> V1 b -> V1 a Source #
Functor ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b Source # (<$) :: a -> U1 b -> U1 a Source #
Functor ( (,) a)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) Source # (<$) :: a0 -> (a, b) -> (a, a0) Source #
Functor ( Map k)
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> Map k a -> Map k b Source # (<$) :: a -> Map k b -> Map k a Source #
Functor ( HashMap k)
Instance details Defined in Data.HashMap.Internal Methods fmap :: (a -> b) -> HashMap k a -> HashMap k b Source # (<$) :: a -> HashMap k b -> HashMap k a Source #
Functor ( ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods fmap :: (a -> b) -> ST s a -> ST s b Source # (<$) :: a -> ST s b -> ST s a Source #
Functor ( Array i)	Since: base-2.1
Instance details Defined in GHC.Arr Methods fmap :: (a -> b) -> Array i a -> Array i b Source # (<$) :: a -> Array i b -> Array i a Source #
Functor ( IResult i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods fmap :: (a -> b) -> IResult i a -> IResult i b Source # (<$) :: a -> IResult i b -> IResult i a Source #
Functor ( Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods fmap :: (a -> b) -> Parser i a -> Parser i b Source # (<$) :: a -> Parser i b -> Parser i a Source #
Functor ( Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a0 -> b) -> Arg a a0 -> Arg a b Source # (<$) :: a0 -> Arg a b -> Arg a a0 Source #
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 Source # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a Source #
Arrow a => Functor ( ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #
Functor ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b Source # (<$) :: a -> Proxy b -> Proxy a Source #
Functor ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods fmap :: (a -> b) -> Decoder s a -> Decoder s b Source # (<$) :: a -> Decoder s b -> Decoder s a Source #
Functor ( Format r)	Not particularly useful, but could be.
Instance details Defined in Formatting.Internal Methods fmap :: (a -> b) -> Format r a -> Format r b Source # (<$) :: a -> Format r b -> Format r a Source #
Functor m => Functor ( ListT m)
Instance details Defined in Control.Monad.Trans.List Methods fmap :: (a -> b) -> ListT m a -> ListT m b Source # (<$) :: a -> ListT m b -> ListT m a Source #
Functor ( These a)
Instance details Defined in Data.These Methods fmap :: (a0 -> b) -> These a a0 -> These a b Source # (<$) :: a0 -> These a b -> These a a0 Source #
Functor ( Pair e)
Instance details Defined in Data.Strict.Tuple Methods fmap :: (a -> b) -> Pair e a -> Pair e b Source # (<$) :: a -> Pair e b -> Pair e a Source #
Functor ( These a)
Instance details Defined in Data.Strict.These Methods fmap :: (a0 -> b) -> These a a0 -> These a b Source # (<$) :: a0 -> These a b -> These a a0 Source #
Functor ( Either a)
Instance details Defined in Data.Strict.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b Source # (<$) :: a0 -> Either a b -> Either a a0 Source #
Functor m => Functor ( MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b Source # (<$) :: a -> MaybeT m b -> MaybeT m a Source #
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 Source # (<$) :: a -> Rec1 f b -> Rec1 f a Source #
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 Source # (<$) :: a -> URec Char b -> URec Char a Source #
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 Source # (<$) :: a -> URec Double b -> URec Double a Source #
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 Source # (<$) :: a -> URec Float b -> URec Float a Source #
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 Source # (<$) :: a -> URec Int b -> URec Int a Source #
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 Source # (<$) :: a -> URec Word b -> URec Word a Source #
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 Source # (<$) :: a -> URec ( Ptr ()) b -> URec ( Ptr ()) a Source #
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) Source # (<$) :: a0 -> (a, b, b0) -> (a, b, a0) Source #
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 Source # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source #
Functor m => Functor ( Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b Source # (<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 Source #
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 Source # (<$) :: a -> Const m b -> Const m a Source #
Functor f => Functor ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Ap f a -> Ap f b Source # (<$) :: a -> Ap f b -> Ap f a Source #
Functor f => Functor ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Alt f a -> Alt f b Source # (<$) :: a -> Alt f b -> Alt f a Source #
Functor m => Functor ( IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fmap :: (a -> b) -> IdentityT m a -> IdentityT m b Source # (<$) :: a -> IdentityT m b -> IdentityT m a Source #
( 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 Source # (<$) :: a -> WhenMissing f x b -> WhenMissing f x a Source #
Functor m => Functor ( ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b Source # (<$) :: a -> ErrorT e m b -> ErrorT e m a Source #
Functor m => Functor ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b Source # (<$) :: a -> ExceptT e m b -> ExceptT e m a Source #
Functor m => Functor ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b Source # (<$) :: a -> ReaderT r m b -> ReaderT r m a Source #
Functor m => Functor ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b Source # (<$) :: a -> StateT s m b -> StateT s m a Source #
Functor m => Functor ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b Source # (<$) :: a -> StateT s m b -> StateT s m a Source #
Functor m => Functor ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b Source # (<$) :: a -> WriterT w m b -> WriterT w m a Source #
Functor m => Functor ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b Source # (<$) :: a -> WriterT w m b -> WriterT w m a Source #
Functor ( Tagged s)
Instance details Defined in Data.Tagged Methods fmap :: (a -> b) -> Tagged s a -> Tagged s b Source # (<$) :: a -> Tagged s b -> Tagged s a Source #
( Functor f, Functor g) => Functor ( These1 f g)
Instance details Defined in Data.Functor.These Methods fmap :: (a -> b) -> These1 f g a -> These1 f g b Source # (<$) :: a -> These1 f g b -> These1 f g a Source #
Functor ((->) r :: Type -> Type )	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b Source # (<$) :: a -> (r -> b) -> r -> a Source #
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 Source # (<$) :: a -> K1 i c b -> K1 i c a Source #
( 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 Source # (<$) :: a -> (f :+: g) b -> (f :+: g) a Source #
( 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 Source # (<$) :: a -> (f :: g) b -> (f :: g) a Source #
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) Source # (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) Source #
( Functor f, Functor g) => Functor ( Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods fmap :: (a -> b) -> Product f g a -> Product f g b Source # (<$) :: a -> Product f g b -> Product f g a Source #
( Functor f, Functor g) => Functor ( Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fmap :: (a -> b) -> Sum f g a -> Sum f g b Source # (<$) :: a -> Sum f g b -> Sum f g a Source #
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 Source # (<$) :: a -> WhenMatched f x y b -> WhenMatched f x y a Source #
( 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 Source # (<$) :: a -> WhenMissing f k x b -> WhenMissing f k x a Source #
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 Source # (<$) :: a -> M1 i c f b -> M1 i c f a Source #
( 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 Source # (<$) :: a -> (f :.: g) b -> (f :.: g) a Source #
( Functor f, Functor g) => Functor ( Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b Source # (<$) :: a -> Compose f g b -> Compose f g a Source #
Bifunctor p => Functor ( Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods fmap :: (a0 -> b) -> Flip p a a0 -> Flip p a b Source # (<$) :: a0 -> Flip p a b -> Flip p a a0 Source #
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 Source # (<$) :: a -> WhenMatched f k x y b -> WhenMatched f k x y a Source #
Functor m => Functor ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b Source # (<$) :: a -> RWST r w s m b -> RWST r w s m a Source #
Functor m => Functor ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b Source # (<$) :: a -> RWST r w s m b -> RWST r w s m a Source #
( Functor (f a), Functor (g a)) => Functor ( Sum f g a)
Instance details Defined in Data.Bifunctor.Sum Methods fmap :: (a0 -> b) -> Sum f g a a0 -> Sum f g a b Source # (<$) :: a0 -> Sum f g a b -> Sum f g a a0 Source #
( Functor (f a), Functor (g a)) => Functor ( Product f g a)
Instance details Defined in Data.Bifunctor.Product Methods fmap :: (a0 -> b) -> Product f g a a0 -> Product f g a b Source # (<$) :: a0 -> Product f g a b -> Product f g a a0 Source #
( Functor f, Bifunctor p) => Functor ( Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods fmap :: (a0 -> b) -> Tannen f p a a0 -> Tannen f p a b Source # (<$) :: a0 -> Tannen f p a b -> Tannen f p a a0 Source #
( Bifunctor p, Functor g) => Functor ( Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods fmap :: (a0 -> b) -> Biff p f g a a0 -> Biff p f g a b Source # (<$) :: a0 -> Biff p f g a b -> Biff p f g a a0 Source #

class Num a where Source #

Basic numeric class.

The Haskell Report defines no laws for Num . However, ( + ) and ( * ) are customarily expected to define a ring and have the following properties:

Associativity of ( + ): (x + y) + z = x + (y + z)
Commutativity of ( + ): x + y = y + x
fromInteger 0 is the additive identity: x + fromInteger 0 = x
negate gives the additive inverse: x + negate x = fromInteger 0
Associativity of ( * ): (x * y) * z = x * (y * z)
fromInteger 1 is the multiplicative identity: x * fromInteger 1 = x and fromInteger 1 * x = x
Distributivity of ( * ) with respect to ( + ): a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

Minimal complete definition

(+) , (*) , abs , signum , fromInteger , ( negate | (-) )

Methods

(+) :: a -> a -> a infixl 6 Source #

(-) :: a -> a -> a infixl 6 Source #

(*) :: a -> a -> a infixl 7 Source #

negate :: a -> a Source #

Unary negation.

abs :: a -> a Source #

Absolute value.

signum :: a -> a Source #

Sign of a number. The functions abs and signum should satisfy the law:

abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

fromInteger :: Integer -> a Source #

Conversion from an Integer . An integer literal represents the application of the function fromInteger to the appropriate value of type Integer , so such literals have type ( Num a) => a .

Instances

Instances details

Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int Source # (-) :: Int -> Int -> Int Source # (*) :: Int -> Int -> Int Source # negate :: Int -> Int Source # abs :: Int -> Int Source # signum :: Int -> Int Source # fromInteger :: Integer -> Int Source #
Num Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int8 -> Int8 -> Int8 Source # (-) :: Int8 -> Int8 -> Int8 Source # (*) :: Int8 -> Int8 -> Int8 Source # negate :: Int8 -> Int8 Source # abs :: Int8 -> Int8 Source # signum :: Int8 -> Int8 Source # fromInteger :: Integer -> Int8 Source #
Num Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int16 -> Int16 -> Int16 Source # (-) :: Int16 -> Int16 -> Int16 Source # (*) :: Int16 -> Int16 -> Int16 Source # negate :: Int16 -> Int16 Source # abs :: Int16 -> Int16 Source # signum :: Int16 -> Int16 Source # fromInteger :: Integer -> Int16 Source #
Num Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int32 -> Int32 -> Int32 Source # (-) :: Int32 -> Int32 -> Int32 Source # (*) :: Int32 -> Int32 -> Int32 Source # negate :: Int32 -> Int32 Source # abs :: Int32 -> Int32 Source # signum :: Int32 -> Int32 Source # fromInteger :: Integer -> Int32 Source #
Num Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int64 -> Int64 -> Int64 Source # (-) :: Int64 -> Int64 -> Int64 Source # (*) :: Int64 -> Int64 -> Int64 Source # negate :: Int64 -> Int64 Source # abs :: Int64 -> Int64 Source # signum :: Int64 -> Int64 Source # fromInteger :: Integer -> Int64 Source #
Num Integer	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Integer -> Integer -> Integer Source # (-) :: Integer -> Integer -> Integer Source # (*) :: Integer -> Integer -> Integer Source # negate :: Integer -> Integer Source # abs :: Integer -> Integer Source # signum :: Integer -> Integer Source # fromInteger :: Integer -> Integer Source #
Num Natural	Note that `Natural` 's `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural Source # (-) :: Natural -> Natural -> Natural Source # (*) :: Natural -> Natural -> Natural Source # negate :: Natural -> Natural Source # abs :: Natural -> Natural Source # signum :: Natural -> Natural Source # fromInteger :: Integer -> Natural Source #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word Source # (-) :: Word -> Word -> Word Source # (*) :: Word -> Word -> Word Source # negate :: Word -> Word Source # abs :: Word -> Word Source # signum :: Word -> Word Source # fromInteger :: Integer -> Word Source #
Num Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word8 -> Word8 -> Word8 Source # (-) :: Word8 -> Word8 -> Word8 Source # (*) :: Word8 -> Word8 -> Word8 Source # negate :: Word8 -> Word8 Source # abs :: Word8 -> Word8 Source # signum :: Word8 -> Word8 Source # fromInteger :: Integer -> Word8 Source #
Num Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word16 -> Word16 -> Word16 Source # (-) :: Word16 -> Word16 -> Word16 Source # (*) :: Word16 -> Word16 -> Word16 Source # negate :: Word16 -> Word16 Source # abs :: Word16 -> Word16 Source # signum :: Word16 -> Word16 Source # fromInteger :: Integer -> Word16 Source #
Num Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word32 -> Word32 -> Word32 Source # (-) :: Word32 -> Word32 -> Word32 Source # (*) :: Word32 -> Word32 -> Word32 Source # negate :: Word32 -> Word32 Source # abs :: Word32 -> Word32 Source # signum :: Word32 -> Word32 Source # fromInteger :: Integer -> Word32 Source #
Num Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word64 -> Word64 -> Word64 Source # (-) :: Word64 -> Word64 -> Word64 Source # (*) :: Word64 -> Word64 -> Word64 Source # negate :: Word64 -> Word64 Source # abs :: Word64 -> Word64 Source # signum :: Word64 -> Word64 Source # fromInteger :: Integer -> Word64 Source #
Num Scientific	WARNING: `+` and `-` compute the `Integer` magnitude: `10^e` where `e` is the difference between the `base10Exponent s` of the arguments. If these methods are applied to arguments which have huge exponents this could fill up all space and crash your program! So don't apply these methods to scientific numbers coming from untrusted sources. The other methods can be used safely.
Instance details Defined in Data.Scientific Methods (+) :: Scientific -> Scientific -> Scientific Source # (-) :: Scientific -> Scientific -> Scientific Source # (*) :: Scientific -> Scientific -> Scientific Source # negate :: Scientific -> Scientific Source # abs :: Scientific -> Scientific Source # signum :: Scientific -> Scientific Source # fromInteger :: Integer -> Scientific Source #
Num Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods (+) :: Pos -> Pos -> Pos Source # (-) :: Pos -> Pos -> Pos Source # (*) :: Pos -> Pos -> Pos Source # negate :: Pos -> Pos Source # abs :: Pos -> Pos Source # signum :: Pos -> Pos Source # fromInteger :: Integer -> Pos Source #
Num CDev
Instance details Defined in System.Posix.Types Methods (+) :: CDev -> CDev -> CDev Source # (-) :: CDev -> CDev -> CDev Source # (*) :: CDev -> CDev -> CDev Source # negate :: CDev -> CDev Source # abs :: CDev -> CDev Source # signum :: CDev -> CDev Source # fromInteger :: Integer -> CDev Source #
Num CIno
Instance details Defined in System.Posix.Types Methods (+) :: CIno -> CIno -> CIno Source # (-) :: CIno -> CIno -> CIno Source # (*) :: CIno -> CIno -> CIno Source # negate :: CIno -> CIno Source # abs :: CIno -> CIno Source # signum :: CIno -> CIno Source # fromInteger :: Integer -> CIno Source #
Num CMode
Instance details Defined in System.Posix.Types Methods (+) :: CMode -> CMode -> CMode Source # (-) :: CMode -> CMode -> CMode Source # (*) :: CMode -> CMode -> CMode Source # negate :: CMode -> CMode Source # abs :: CMode -> CMode Source # signum :: CMode -> CMode Source # fromInteger :: Integer -> CMode Source #
Num COff
Instance details Defined in System.Posix.Types Methods (+) :: COff -> COff -> COff Source # (-) :: COff -> COff -> COff Source # (*) :: COff -> COff -> COff Source # negate :: COff -> COff Source # abs :: COff -> COff Source # signum :: COff -> COff Source # fromInteger :: Integer -> COff Source #
Num CPid
Instance details Defined in System.Posix.Types Methods (+) :: CPid -> CPid -> CPid Source # (-) :: CPid -> CPid -> CPid Source # (*) :: CPid -> CPid -> CPid Source # negate :: CPid -> CPid Source # abs :: CPid -> CPid Source # signum :: CPid -> CPid Source # fromInteger :: Integer -> CPid Source #
Num CSsize
Instance details Defined in System.Posix.Types Methods (+) :: CSsize -> CSsize -> CSsize Source # (-) :: CSsize -> CSsize -> CSsize Source # (*) :: CSsize -> CSsize -> CSsize Source # negate :: CSsize -> CSsize Source # abs :: CSsize -> CSsize Source # signum :: CSsize -> CSsize Source # fromInteger :: Integer -> CSsize Source #
Num CGid
Instance details Defined in System.Posix.Types Methods (+) :: CGid -> CGid -> CGid Source # (-) :: CGid -> CGid -> CGid Source # (*) :: CGid -> CGid -> CGid Source # negate :: CGid -> CGid Source # abs :: CGid -> CGid Source # signum :: CGid -> CGid Source # fromInteger :: Integer -> CGid Source #
Num CNlink
Instance details Defined in System.Posix.Types Methods (+) :: CNlink -> CNlink -> CNlink Source # (-) :: CNlink -> CNlink -> CNlink Source # (*) :: CNlink -> CNlink -> CNlink Source # negate :: CNlink -> CNlink Source # abs :: CNlink -> CNlink Source # signum :: CNlink -> CNlink Source # fromInteger :: Integer -> CNlink Source #
Num CUid
Instance details Defined in System.Posix.Types Methods (+) :: CUid -> CUid -> CUid Source # (-) :: CUid -> CUid -> CUid Source # (*) :: CUid -> CUid -> CUid Source # negate :: CUid -> CUid Source # abs :: CUid -> CUid Source # signum :: CUid -> CUid Source # fromInteger :: Integer -> CUid Source #
Num CCc
Instance details Defined in System.Posix.Types Methods (+) :: CCc -> CCc -> CCc Source # (-) :: CCc -> CCc -> CCc Source # (*) :: CCc -> CCc -> CCc Source # negate :: CCc -> CCc Source # abs :: CCc -> CCc Source # signum :: CCc -> CCc Source # fromInteger :: Integer -> CCc Source #
Num CSpeed
Instance details Defined in System.Posix.Types Methods (+) :: CSpeed -> CSpeed -> CSpeed Source # (-) :: CSpeed -> CSpeed -> CSpeed Source # (*) :: CSpeed -> CSpeed -> CSpeed Source # negate :: CSpeed -> CSpeed Source # abs :: CSpeed -> CSpeed Source # signum :: CSpeed -> CSpeed Source # fromInteger :: Integer -> CSpeed Source #
Num CTcflag
Instance details Defined in System.Posix.Types Methods (+) :: CTcflag -> CTcflag -> CTcflag Source # (-) :: CTcflag -> CTcflag -> CTcflag Source # (*) :: CTcflag -> CTcflag -> CTcflag Source # negate :: CTcflag -> CTcflag Source # abs :: CTcflag -> CTcflag Source # signum :: CTcflag -> CTcflag Source # fromInteger :: Integer -> CTcflag Source #
Num CRLim
Instance details Defined in System.Posix.Types Methods (+) :: CRLim -> CRLim -> CRLim Source # (-) :: CRLim -> CRLim -> CRLim Source # (*) :: CRLim -> CRLim -> CRLim Source # negate :: CRLim -> CRLim Source # abs :: CRLim -> CRLim Source # signum :: CRLim -> CRLim Source # fromInteger :: Integer -> CRLim Source #
Num CBlkSize
Instance details Defined in System.Posix.Types Methods (+) :: CBlkSize -> CBlkSize -> CBlkSize Source # (-) :: CBlkSize -> CBlkSize -> CBlkSize Source # (*) :: CBlkSize -> CBlkSize -> CBlkSize Source # negate :: CBlkSize -> CBlkSize Source # abs :: CBlkSize -> CBlkSize Source # signum :: CBlkSize -> CBlkSize Source # fromInteger :: Integer -> CBlkSize Source #
Num CBlkCnt
Instance details Defined in System.Posix.Types Methods (+) :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # (-) :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # (*) :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # negate :: CBlkCnt -> CBlkCnt Source # abs :: CBlkCnt -> CBlkCnt Source # signum :: CBlkCnt -> CBlkCnt Source # fromInteger :: Integer -> CBlkCnt Source #
Num CClockId
Instance details Defined in System.Posix.Types Methods (+) :: CClockId -> CClockId -> CClockId Source # (-) :: CClockId -> CClockId -> CClockId Source # (*) :: CClockId -> CClockId -> CClockId Source # negate :: CClockId -> CClockId Source # abs :: CClockId -> CClockId Source # signum :: CClockId -> CClockId Source # fromInteger :: Integer -> CClockId Source #
Num CFsBlkCnt
Instance details Defined in System.Posix.Types Methods (+) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # (-) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # (*) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # negate :: CFsBlkCnt -> CFsBlkCnt Source # abs :: CFsBlkCnt -> CFsBlkCnt Source # signum :: CFsBlkCnt -> CFsBlkCnt Source # fromInteger :: Integer -> CFsBlkCnt Source #
Num CFsFilCnt
Instance details Defined in System.Posix.Types Methods (+) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # (-) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # (*) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # negate :: CFsFilCnt -> CFsFilCnt Source # abs :: CFsFilCnt -> CFsFilCnt Source # signum :: CFsFilCnt -> CFsFilCnt Source # fromInteger :: Integer -> CFsFilCnt Source #
Num CId
Instance details Defined in System.Posix.Types Methods (+) :: CId -> CId -> CId Source # (-) :: CId -> CId -> CId Source # (*) :: CId -> CId -> CId Source # negate :: CId -> CId Source # abs :: CId -> CId Source # signum :: CId -> CId Source # fromInteger :: Integer -> CId Source #
Num CKey
Instance details Defined in System.Posix.Types Methods (+) :: CKey -> CKey -> CKey Source # (-) :: CKey -> CKey -> CKey Source # (*) :: CKey -> CKey -> CKey Source # negate :: CKey -> CKey Source # abs :: CKey -> CKey Source # signum :: CKey -> CKey Source # fromInteger :: Integer -> CKey Source #
Num CSocklen
Instance details Defined in System.Posix.Types Methods (+) :: CSocklen -> CSocklen -> CSocklen Source # (-) :: CSocklen -> CSocklen -> CSocklen Source # (*) :: CSocklen -> CSocklen -> CSocklen Source # negate :: CSocklen -> CSocklen Source # abs :: CSocklen -> CSocklen Source # signum :: CSocklen -> CSocklen Source # fromInteger :: Integer -> CSocklen Source #
Num CNfds
Instance details Defined in System.Posix.Types Methods (+) :: CNfds -> CNfds -> CNfds Source # (-) :: CNfds -> CNfds -> CNfds Source # (*) :: CNfds -> CNfds -> CNfds Source # negate :: CNfds -> CNfds Source # abs :: CNfds -> CNfds Source # signum :: CNfds -> CNfds Source # fromInteger :: Integer -> CNfds Source #
Num Fd
Instance details Defined in System.Posix.Types Methods (+) :: Fd -> Fd -> Fd Source # (-) :: Fd -> Fd -> Fd Source # (*) :: Fd -> Fd -> Fd Source # negate :: Fd -> Fd Source # abs :: Fd -> Fd Source # signum :: Fd -> Fd Source # fromInteger :: Integer -> Fd Source #
Num CChar
Instance details Defined in Foreign.C.Types Methods (+) :: CChar -> CChar -> CChar Source # (-) :: CChar -> CChar -> CChar Source # (*) :: CChar -> CChar -> CChar Source # negate :: CChar -> CChar Source # abs :: CChar -> CChar Source # signum :: CChar -> CChar Source # fromInteger :: Integer -> CChar Source #
Num CSChar
Instance details Defined in Foreign.C.Types Methods (+) :: CSChar -> CSChar -> CSChar Source # (-) :: CSChar -> CSChar -> CSChar Source # (*) :: CSChar -> CSChar -> CSChar Source # negate :: CSChar -> CSChar Source # abs :: CSChar -> CSChar Source # signum :: CSChar -> CSChar Source # fromInteger :: Integer -> CSChar Source #
Num CUChar
Instance details Defined in Foreign.C.Types Methods (+) :: CUChar -> CUChar -> CUChar Source # (-) :: CUChar -> CUChar -> CUChar Source # (*) :: CUChar -> CUChar -> CUChar Source # negate :: CUChar -> CUChar Source # abs :: CUChar -> CUChar Source # signum :: CUChar -> CUChar Source # fromInteger :: Integer -> CUChar Source #
Num CShort
Instance details Defined in Foreign.C.Types Methods (+) :: CShort -> CShort -> CShort Source # (-) :: CShort -> CShort -> CShort Source # (*) :: CShort -> CShort -> CShort Source # negate :: CShort -> CShort Source # abs :: CShort -> CShort Source # signum :: CShort -> CShort Source # fromInteger :: Integer -> CShort Source #
Num CUShort
Instance details Defined in Foreign.C.Types Methods (+) :: CUShort -> CUShort -> CUShort Source # (-) :: CUShort -> CUShort -> CUShort Source # (*) :: CUShort -> CUShort -> CUShort Source # negate :: CUShort -> CUShort Source # abs :: CUShort -> CUShort Source # signum :: CUShort -> CUShort Source # fromInteger :: Integer -> CUShort Source #
Num CInt
Instance details Defined in Foreign.C.Types Methods (+) :: CInt -> CInt -> CInt Source # (-) :: CInt -> CInt -> CInt Source # (*) :: CInt -> CInt -> CInt Source # negate :: CInt -> CInt Source # abs :: CInt -> CInt Source # signum :: CInt -> CInt Source # fromInteger :: Integer -> CInt Source #
Num CUInt
Instance details Defined in Foreign.C.Types Methods (+) :: CUInt -> CUInt -> CUInt Source # (-) :: CUInt -> CUInt -> CUInt Source # (*) :: CUInt -> CUInt -> CUInt Source # negate :: CUInt -> CUInt Source # abs :: CUInt -> CUInt Source # signum :: CUInt -> CUInt Source # fromInteger :: Integer -> CUInt Source #
Num CLong
Instance details Defined in Foreign.C.Types Methods (+) :: CLong -> CLong -> CLong Source # (-) :: CLong -> CLong -> CLong Source # (*) :: CLong -> CLong -> CLong Source # negate :: CLong -> CLong Source # abs :: CLong -> CLong Source # signum :: CLong -> CLong Source # fromInteger :: Integer -> CLong Source #
Num CULong
Instance details Defined in Foreign.C.Types Methods (+) :: CULong -> CULong -> CULong Source # (-) :: CULong -> CULong -> CULong Source # (*) :: CULong -> CULong -> CULong Source # negate :: CULong -> CULong Source # abs :: CULong -> CULong Source # signum :: CULong -> CULong Source # fromInteger :: Integer -> CULong Source #
Num CLLong
Instance details Defined in Foreign.C.Types Methods (+) :: CLLong -> CLLong -> CLLong Source # (-) :: CLLong -> CLLong -> CLLong Source # (*) :: CLLong -> CLLong -> CLLong Source # negate :: CLLong -> CLLong Source # abs :: CLLong -> CLLong Source # signum :: CLLong -> CLLong Source # fromInteger :: Integer -> CLLong Source #
Num CULLong
Instance details Defined in Foreign.C.Types Methods (+) :: CULLong -> CULLong -> CULLong Source # (-) :: CULLong -> CULLong -> CULLong Source # (*) :: CULLong -> CULLong -> CULLong Source # negate :: CULLong -> CULLong Source # abs :: CULLong -> CULLong Source # signum :: CULLong -> CULLong Source # fromInteger :: Integer -> CULLong Source #
Num CBool
Instance details Defined in Foreign.C.Types Methods (+) :: CBool -> CBool -> CBool Source # (-) :: CBool -> CBool -> CBool Source # (*) :: CBool -> CBool -> CBool Source # negate :: CBool -> CBool Source # abs :: CBool -> CBool Source # signum :: CBool -> CBool Source # fromInteger :: Integer -> CBool Source #
Num CFloat
Instance details Defined in Foreign.C.Types Methods (+) :: CFloat -> CFloat -> CFloat Source # (-) :: CFloat -> CFloat -> CFloat Source # (*) :: CFloat -> CFloat -> CFloat Source # negate :: CFloat -> CFloat Source # abs :: CFloat -> CFloat Source # signum :: CFloat -> CFloat Source # fromInteger :: Integer -> CFloat Source #
Num CDouble
Instance details Defined in Foreign.C.Types Methods (+) :: CDouble -> CDouble -> CDouble Source # (-) :: CDouble -> CDouble -> CDouble Source # (*) :: CDouble -> CDouble -> CDouble Source # negate :: CDouble -> CDouble Source # abs :: CDouble -> CDouble Source # signum :: CDouble -> CDouble Source # fromInteger :: Integer -> CDouble Source #
Num CPtrdiff
Instance details Defined in Foreign.C.Types Methods (+) :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # (-) :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # (*) :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # negate :: CPtrdiff -> CPtrdiff Source # abs :: CPtrdiff -> CPtrdiff Source # signum :: CPtrdiff -> CPtrdiff Source # fromInteger :: Integer -> CPtrdiff Source #
Num CSize
Instance details Defined in Foreign.C.Types Methods (+) :: CSize -> CSize -> CSize Source # (-) :: CSize -> CSize -> CSize Source # (*) :: CSize -> CSize -> CSize Source # negate :: CSize -> CSize Source # abs :: CSize -> CSize Source # signum :: CSize -> CSize Source # fromInteger :: Integer -> CSize Source #
Num CWchar
Instance details Defined in Foreign.C.Types Methods (+) :: CWchar -> CWchar -> CWchar Source # (-) :: CWchar -> CWchar -> CWchar Source # (*) :: CWchar -> CWchar -> CWchar Source # negate :: CWchar -> CWchar Source # abs :: CWchar -> CWchar Source # signum :: CWchar -> CWchar Source # fromInteger :: Integer -> CWchar Source #
Num CSigAtomic
Instance details Defined in Foreign.C.Types Methods (+) :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # (-) :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # (*) :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # negate :: CSigAtomic -> CSigAtomic Source # abs :: CSigAtomic -> CSigAtomic Source # signum :: CSigAtomic -> CSigAtomic Source # fromInteger :: Integer -> CSigAtomic Source #
Num CClock
Instance details Defined in Foreign.C.Types Methods (+) :: CClock -> CClock -> CClock Source # (-) :: CClock -> CClock -> CClock Source # (*) :: CClock -> CClock -> CClock Source # negate :: CClock -> CClock Source # abs :: CClock -> CClock Source # signum :: CClock -> CClock Source # fromInteger :: Integer -> CClock Source #
Num CTime
Instance details Defined in Foreign.C.Types Methods (+) :: CTime -> CTime -> CTime Source # (-) :: CTime -> CTime -> CTime Source # (*) :: CTime -> CTime -> CTime Source # negate :: CTime -> CTime Source # abs :: CTime -> CTime Source # signum :: CTime -> CTime Source # fromInteger :: Integer -> CTime Source #
Num CUSeconds
Instance details Defined in Foreign.C.Types Methods (+) :: CUSeconds -> CUSeconds -> CUSeconds Source # (-) :: CUSeconds -> CUSeconds -> CUSeconds Source # (*) :: CUSeconds -> CUSeconds -> CUSeconds Source # negate :: CUSeconds -> CUSeconds Source # abs :: CUSeconds -> CUSeconds Source # signum :: CUSeconds -> CUSeconds Source # fromInteger :: Integer -> CUSeconds Source #
Num CSUSeconds
Instance details Defined in Foreign.C.Types Methods (+) :: CSUSeconds -> CSUSeconds -> CSUSeconds Source # (-) :: CSUSeconds -> CSUSeconds -> CSUSeconds Source # (*) :: CSUSeconds -> CSUSeconds -> CSUSeconds Source # negate :: CSUSeconds -> CSUSeconds Source # abs :: CSUSeconds -> CSUSeconds Source # signum :: CSUSeconds -> CSUSeconds Source # fromInteger :: Integer -> CSUSeconds Source #
Num CIntPtr
Instance details Defined in Foreign.C.Types Methods (+) :: CIntPtr -> CIntPtr -> CIntPtr Source # (-) :: CIntPtr -> CIntPtr -> CIntPtr Source # (*) :: CIntPtr -> CIntPtr -> CIntPtr Source # negate :: CIntPtr -> CIntPtr Source # abs :: CIntPtr -> CIntPtr Source # signum :: CIntPtr -> CIntPtr Source # fromInteger :: Integer -> CIntPtr Source #
Num CUIntPtr
Instance details Defined in Foreign.C.Types Methods (+) :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # (-) :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # (*) :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # negate :: CUIntPtr -> CUIntPtr Source # abs :: CUIntPtr -> CUIntPtr Source # signum :: CUIntPtr -> CUIntPtr Source # fromInteger :: Integer -> CUIntPtr Source #
Num CIntMax
Instance details Defined in Foreign.C.Types Methods (+) :: CIntMax -> CIntMax -> CIntMax Source # (-) :: CIntMax -> CIntMax -> CIntMax Source # (*) :: CIntMax -> CIntMax -> CIntMax Source # negate :: CIntMax -> CIntMax Source # abs :: CIntMax -> CIntMax Source # signum :: CIntMax -> CIntMax Source # fromInteger :: Integer -> CIntMax Source #
Num CUIntMax
Instance details Defined in Foreign.C.Types Methods (+) :: CUIntMax -> CUIntMax -> CUIntMax Source # (-) :: CUIntMax -> CUIntMax -> CUIntMax Source # (*) :: CUIntMax -> CUIntMax -> CUIntMax Source # negate :: CUIntMax -> CUIntMax Source # abs :: CUIntMax -> CUIntMax Source # signum :: CUIntMax -> CUIntMax Source # fromInteger :: Integer -> CUIntMax Source #
Num WordPtr
Instance details Defined in Foreign.Ptr Methods (+) :: WordPtr -> WordPtr -> WordPtr Source # (-) :: WordPtr -> WordPtr -> WordPtr Source # (*) :: WordPtr -> WordPtr -> WordPtr Source # negate :: WordPtr -> WordPtr Source # abs :: WordPtr -> WordPtr Source # signum :: WordPtr -> WordPtr Source # fromInteger :: Integer -> WordPtr Source #
Num IntPtr
Instance details Defined in Foreign.Ptr Methods (+) :: IntPtr -> IntPtr -> IntPtr Source # (-) :: IntPtr -> IntPtr -> IntPtr Source # (*) :: IntPtr -> IntPtr -> IntPtr Source # negate :: IntPtr -> IntPtr Source # abs :: IntPtr -> IntPtr Source # signum :: IntPtr -> IntPtr Source # fromInteger :: Integer -> IntPtr Source #
Num Int54
Instance details Defined in Text.JSON.Canonical.Types Methods (+) :: Int54 -> Int54 -> Int54 Source # (-) :: Int54 -> Int54 -> Int54 Source # (*) :: Int54 -> Int54 -> Int54 Source # negate :: Int54 -> Int54 Source # abs :: Int54 -> Int54 Source # signum :: Int54 -> Int54 Source # fromInteger :: Integer -> Int54 Source #
Num DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods (+) :: DiffTime -> DiffTime -> DiffTime Source # (-) :: DiffTime -> DiffTime -> DiffTime Source # (*) :: DiffTime -> DiffTime -> DiffTime Source # negate :: DiffTime -> DiffTime Source # abs :: DiffTime -> DiffTime Source # signum :: DiffTime -> DiffTime Source # fromInteger :: Integer -> DiffTime Source #
Num NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (+) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime Source # (-) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime Source # (*) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime Source # negate :: NominalDiffTime -> NominalDiffTime Source # abs :: NominalDiffTime -> NominalDiffTime Source # signum :: NominalDiffTime -> NominalDiffTime Source # fromInteger :: Integer -> NominalDiffTime Source #
Num CodePoint
Instance details Defined in Data.Text.Encoding Methods (+) :: CodePoint -> CodePoint -> CodePoint Source # (-) :: CodePoint -> CodePoint -> CodePoint Source # (*) :: CodePoint -> CodePoint -> CodePoint Source # negate :: CodePoint -> CodePoint Source # abs :: CodePoint -> CodePoint Source # signum :: CodePoint -> CodePoint Source # fromInteger :: Integer -> CodePoint Source #
Num DecoderState
Instance details Defined in Data.Text.Encoding Methods (+) :: DecoderState -> DecoderState -> DecoderState Source # (-) :: DecoderState -> DecoderState -> DecoderState Source # (*) :: DecoderState -> DecoderState -> DecoderState Source # negate :: DecoderState -> DecoderState Source # abs :: DecoderState -> DecoderState Source # signum :: DecoderState -> DecoderState Source # fromInteger :: Integer -> DecoderState Source #
Num B
Instance details Defined in Data.Text.Short.Internal Methods (+) :: B -> B -> B Source # (-) :: B -> B -> B Source # (*) :: B -> B -> B Source # negate :: B -> B Source # abs :: B -> B Source # signum :: B -> B Source # fromInteger :: Integer -> B Source #
Integral a => Num ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (+) :: Ratio a -> Ratio a -> Ratio a Source # (-) :: Ratio a -> Ratio a -> Ratio a Source # (*) :: Ratio a -> Ratio a -> Ratio a Source # negate :: Ratio a -> Ratio a Source # abs :: Ratio a -> Ratio a Source # signum :: Ratio a -> Ratio a Source # fromInteger :: Integer -> Ratio a Source #
RealFloat a => Num ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (+) :: Complex a -> Complex a -> Complex a Source # (-) :: Complex a -> Complex a -> Complex a Source # (*) :: Complex a -> Complex a -> Complex a Source # negate :: Complex a -> Complex a Source # abs :: Complex a -> Complex a Source # signum :: Complex a -> Complex a Source # fromInteger :: Integer -> Complex a Source #
Num a => Num ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (+) :: Min a -> Min a -> Min a Source # (-) :: Min a -> Min a -> Min a Source # (*) :: Min a -> Min a -> Min a Source # negate :: Min a -> Min a Source # abs :: Min a -> Min a Source # signum :: Min a -> Min a Source # fromInteger :: Integer -> Min a Source #
Num a => Num ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (+) :: Max a -> Max a -> Max a Source # (-) :: Max a -> Max a -> Max a Source # (*) :: Max a -> Max a -> Max a Source # negate :: Max a -> Max a Source # abs :: Max a -> Max a Source # signum :: Max a -> Max a Source # fromInteger :: Integer -> Max a Source #
Num a => Num ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a Source # (-) :: Identity a -> Identity a -> Identity a Source # (*) :: Identity a -> Identity a -> Identity a Source # negate :: Identity a -> Identity a Source # abs :: Identity a -> Identity a Source # signum :: Identity a -> Identity a Source # fromInteger :: Integer -> Identity a Source #
Num a => Num ( Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Sum a -> Sum a -> Sum a Source # (-) :: Sum a -> Sum a -> Sum a Source # (*) :: Sum a -> Sum a -> Sum a Source # negate :: Sum a -> Sum a Source # abs :: Sum a -> Sum a Source # signum :: Sum a -> Sum a Source # fromInteger :: Integer -> Sum a Source #
Num a => Num ( Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Product a -> Product a -> Product a Source # (-) :: Product a -> Product a -> Product a Source # (*) :: Product a -> Product a -> Product a Source # negate :: Product a -> Product a Source # abs :: Product a -> Product a Source # signum :: Product a -> Product a Source # fromInteger :: Integer -> Product a Source #
Num a => Num ( Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (+) :: Down a -> Down a -> Down a Source # (-) :: Down a -> Down a -> Down a Source # (*) :: Down a -> Down a -> Down a Source # negate :: Down a -> Down a Source # abs :: Down a -> Down a Source # signum :: Down a -> Down a Source # fromInteger :: Integer -> Down a Source #
Num a => Num ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods (+) :: Hex a -> Hex a -> Hex a Source # (-) :: Hex a -> Hex a -> Hex a Source # (*) :: Hex a -> Hex a -> Hex a Source # negate :: Hex a -> Hex a Source # abs :: Hex a -> Hex a Source # signum :: Hex a -> Hex a Source # fromInteger :: Integer -> Hex a Source #
Num a => Num ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods (+) :: Shown a -> Shown a -> Shown a Source # (-) :: Shown a -> Shown a -> Shown a Source # (*) :: Shown a -> Shown a -> Shown a Source # negate :: Shown a -> Shown a Source # abs :: Shown a -> Shown a Source # signum :: Shown a -> Shown a Source # fromInteger :: Integer -> Shown a Source #
HasResolution a => Num ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (+) :: Fixed a -> Fixed a -> Fixed a Source # (-) :: Fixed a -> Fixed a -> Fixed a Source # (*) :: Fixed a -> Fixed a -> Fixed a Source # negate :: Fixed a -> Fixed a Source # abs :: Fixed a -> Fixed a Source # signum :: Fixed a -> Fixed a Source # fromInteger :: Integer -> Fixed a Source #
Num a => Num ( 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 Source # (-) :: Const a b -> Const a b -> Const a b Source # (*) :: Const a b -> Const a b -> Const a b Source # negate :: Const a b -> Const a b Source # abs :: Const a b -> Const a b Source # signum :: Const a b -> Const a b Source # fromInteger :: Integer -> Const a b Source #
( Applicative f, Num a) => Num ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (+) :: Ap f a -> Ap f a -> Ap f a Source # (-) :: Ap f a -> Ap f a -> Ap f a Source # (*) :: Ap f a -> Ap f a -> Ap f a Source # negate :: Ap f a -> Ap f a Source # abs :: Ap f a -> Ap f a Source # signum :: Ap f a -> Ap f a Source # fromInteger :: Integer -> Ap f a Source #
Num (f a) => Num ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Alt f a -> Alt f a -> Alt f a Source # (-) :: Alt f a -> Alt f a -> Alt f a Source # (*) :: Alt f a -> Alt f a -> Alt f a Source # negate :: Alt f a -> Alt f a Source # abs :: Alt f a -> Alt f a Source # signum :: Alt f a -> Alt f a Source # fromInteger :: Integer -> Alt f a Source #
Num a => Num ( Tagged s a)
Instance details Defined in Data.Tagged Methods (+) :: Tagged s a -> Tagged s a -> Tagged s a Source # (-) :: Tagged s a -> Tagged s a -> Tagged s a Source # (*) :: Tagged s a -> Tagged s a -> Tagged s a Source # negate :: Tagged s a -> Tagged s a Source # abs :: Tagged s a -> Tagged s a Source # signum :: Tagged s a -> Tagged s a Source # fromInteger :: Integer -> Tagged s a Source #

class Eq a => Ord a where Source #

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord . The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

The Haskell Report defines no laws for Ord . However, <= is customarily expected to implement a non-strict partial order and have the following properties:

Transitivity: if x <= y && y <= z = True , then x <= z = True
Reflexivity: x <= x = True
Antisymmetry: if x <= y && y <= x = True , then x == y = True

Note that the following operator interactions are expected to hold:

x >= y = y <= x
x < y = x <= y && x /= y
x > y = y < x
x < y = compare x y == LT
x > y = compare x y == GT
x == y = compare x y == EQ
min x y == if x <= y then x else y = True
max x y == if x >= y then x else y = True

Note that (7.) and (8.) do not require min and max to return either of their arguments. The result is merely required to equal one of the arguments in terms of (==) .

Minimal complete definition: either compare or <= . Using compare can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Methods

compare :: a -> a -> Ordering Source #

(<) :: a -> a -> Bool infix 4 Source #

(<=) :: a -> a -> Bool infix 4 Source #

(>) :: a -> a -> Bool infix 4 Source #

(>=) :: a -> a -> Bool infix 4 Source #

max :: a -> a -> a Source #

min :: a -> a -> a Source #

Instances

Instances details

Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering Source # (<) :: Bool -> Bool -> Bool Source # (<=) :: Bool -> Bool -> Bool Source # (>) :: Bool -> Bool -> Bool Source # (>=) :: Bool -> Bool -> Bool Source # max :: Bool -> Bool -> Bool Source # min :: Bool -> Bool -> Bool Source #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering Source # (<) :: Char -> Char -> Bool Source # (<=) :: Char -> Char -> Bool Source # (>) :: Char -> Char -> Bool Source # (>=) :: Char -> Char -> Bool Source # max :: Char -> Char -> Char Source # min :: Char -> Char -> Char Source #
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 Source # (<) :: Double -> Double -> Bool Source # (<=) :: Double -> Double -> Bool Source # (>) :: Double -> Double -> Bool Source # (>=) :: Double -> Double -> Bool Source # max :: Double -> Double -> Double Source # min :: Double -> Double -> Double Source #
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 Source # (<) :: Float -> Float -> Bool Source # (<=) :: Float -> Float -> Bool Source # (>) :: Float -> Float -> Bool Source # (>=) :: Float -> Float -> Bool Source # max :: Float -> Float -> Float Source # min :: Float -> Float -> Float Source #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering Source # (<) :: Int -> Int -> Bool Source # (<=) :: Int -> Int -> Bool Source # (>) :: Int -> Int -> Bool Source # (>=) :: Int -> Int -> Bool Source # max :: Int -> Int -> Int Source # min :: Int -> Int -> Int Source #
Ord Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int8 -> Int8 -> Ordering Source # (<) :: Int8 -> Int8 -> Bool Source # (<=) :: Int8 -> Int8 -> Bool Source # (>) :: Int8 -> Int8 -> Bool Source # (>=) :: Int8 -> Int8 -> Bool Source # max :: Int8 -> Int8 -> Int8 Source # min :: Int8 -> Int8 -> Int8 Source #
Ord Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int16 -> Int16 -> Ordering Source # (<) :: Int16 -> Int16 -> Bool Source # (<=) :: Int16 -> Int16 -> Bool Source # (>) :: Int16 -> Int16 -> Bool Source # (>=) :: Int16 -> Int16 -> Bool Source # max :: Int16 -> Int16 -> Int16 Source # min :: Int16 -> Int16 -> Int16 Source #
Ord Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int32 -> Int32 -> Ordering Source # (<) :: Int32 -> Int32 -> Bool Source # (<=) :: Int32 -> Int32 -> Bool Source # (>) :: Int32 -> Int32 -> Bool Source # (>=) :: Int32 -> Int32 -> Bool Source # max :: Int32 -> Int32 -> Int32 Source # min :: Int32 -> Int32 -> Int32 Source #
Ord Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int64 -> Int64 -> Ordering Source # (<) :: Int64 -> Int64 -> Bool Source # (<=) :: Int64 -> Int64 -> Bool Source # (>) :: Int64 -> Int64 -> Bool Source # (>=) :: Int64 -> Int64 -> Bool Source # max :: Int64 -> Int64 -> Int64 Source # min :: Int64 -> Int64 -> Int64 Source #
Ord Integer
Instance details Defined in GHC.Integer.Type Methods compare :: Integer -> Integer -> Ordering Source # (<) :: Integer -> Integer -> Bool Source # (<=) :: Integer -> Integer -> Bool Source # (>) :: Integer -> Integer -> Bool Source # (>=) :: Integer -> Integer -> Bool Source # max :: Integer -> Integer -> Integer Source # min :: Integer -> Integer -> Integer Source #
Ord Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Natural Methods compare :: Natural -> Natural -> Ordering Source # (<) :: Natural -> Natural -> Bool Source # (<=) :: Natural -> Natural -> Bool Source # (>) :: Natural -> Natural -> Bool Source # (>=) :: Natural -> Natural -> Bool Source # max :: Natural -> Natural -> Natural Source # min :: Natural -> Natural -> Natural Source #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering Source # (<) :: Ordering -> Ordering -> Bool Source # (<=) :: Ordering -> Ordering -> Bool Source # (>) :: Ordering -> Ordering -> Bool Source # (>=) :: Ordering -> Ordering -> Bool Source # max :: Ordering -> Ordering -> Ordering Source # min :: Ordering -> Ordering -> Ordering Source #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering Source # (<) :: Word -> Word -> Bool Source # (<=) :: Word -> Word -> Bool Source # (>) :: Word -> Word -> Bool Source # (>=) :: Word -> Word -> Bool Source # max :: Word -> Word -> Word Source # min :: Word -> Word -> Word Source #
Ord Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word8 -> Word8 -> Ordering Source # (<) :: Word8 -> Word8 -> Bool Source # (<=) :: Word8 -> Word8 -> Bool Source # (>) :: Word8 -> Word8 -> Bool Source # (>=) :: Word8 -> Word8 -> Bool Source # max :: Word8 -> Word8 -> Word8 Source # min :: Word8 -> Word8 -> Word8 Source #
Ord Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word16 -> Word16 -> Ordering Source # (<) :: Word16 -> Word16 -> Bool Source # (<=) :: Word16 -> Word16 -> Bool Source # (>) :: Word16 -> Word16 -> Bool Source # (>=) :: Word16 -> Word16 -> Bool Source # max :: Word16 -> Word16 -> Word16 Source # min :: Word16 -> Word16 -> Word16 Source #
Ord Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word32 -> Word32 -> Ordering Source # (<) :: Word32 -> Word32 -> Bool Source # (<=) :: Word32 -> Word32 -> Bool Source # (>) :: Word32 -> Word32 -> Bool Source # (>=) :: Word32 -> Word32 -> Bool Source # max :: Word32 -> Word32 -> Word32 Source # min :: Word32 -> Word32 -> Word32 Source #
Ord Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word64 -> Word64 -> Ordering Source # (<) :: Word64 -> Word64 -> Bool Source # (<=) :: Word64 -> Word64 -> Bool Source # (>) :: Word64 -> Word64 -> Bool Source # (>=) :: Word64 -> Word64 -> Bool Source # max :: Word64 -> Word64 -> Word64 Source # min :: Word64 -> Word64 -> Word64 Source #
Ord SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods compare :: SomeTypeRep -> SomeTypeRep -> Ordering Source # (<) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (<=) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (>) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (>=) :: SomeTypeRep -> SomeTypeRep -> Bool Source # max :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep Source # min :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep Source #
Ord Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Exp -> Exp -> Ordering Source # (<) :: Exp -> Exp -> Bool Source # (<=) :: Exp -> Exp -> Bool Source # (>) :: Exp -> Exp -> Bool Source # (>=) :: Exp -> Exp -> Bool Source # max :: Exp -> Exp -> Exp Source # min :: Exp -> Exp -> Exp Source #
Ord Match
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Match -> Match -> Ordering Source # (<) :: Match -> Match -> Bool Source # (<=) :: Match -> Match -> Bool Source # (>) :: Match -> Match -> Bool Source # (>=) :: Match -> Match -> Bool Source # max :: Match -> Match -> Match Source # min :: Match -> Match -> Match Source #
Ord Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Clause -> Clause -> Ordering Source # (<) :: Clause -> Clause -> Bool Source # (<=) :: Clause -> Clause -> Bool Source # (>) :: Clause -> Clause -> Bool Source # (>=) :: Clause -> Clause -> Bool Source # max :: Clause -> Clause -> Clause Source # min :: Clause -> Clause -> Clause Source #
Ord Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Pat -> Pat -> Ordering Source # (<) :: Pat -> Pat -> Bool Source # (<=) :: Pat -> Pat -> Bool Source # (>) :: Pat -> Pat -> Bool Source # (>=) :: Pat -> Pat -> Bool Source # max :: Pat -> Pat -> Pat Source # min :: Pat -> Pat -> Pat Source #
Ord Type
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Type -> Type -> Ordering Source # (<) :: Type -> Type -> Bool Source # (<=) :: Type -> Type -> Bool Source # (>) :: Type -> Type -> Bool Source # (>=) :: Type -> Type -> Bool Source # max :: Type -> Type -> Type Source # min :: Type -> Type -> Type Source #
Ord Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Dec -> Dec -> Ordering Source # (<) :: Dec -> Dec -> Bool Source # (<=) :: Dec -> Dec -> Bool Source # (>) :: Dec -> Dec -> Bool Source # (>=) :: Dec -> Dec -> Bool Source # max :: Dec -> Dec -> Dec Source # min :: Dec -> Dec -> Dec Source #
Ord Name
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Name -> Name -> Ordering Source # (<) :: Name -> Name -> Bool Source # (<=) :: Name -> Name -> Bool Source # (>) :: Name -> Name -> Bool Source # (>=) :: Name -> Name -> Bool Source # max :: Name -> Name -> Name Source # min :: Name -> Name -> Name Source #
Ord FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FunDep -> FunDep -> Ordering Source # (<) :: FunDep -> FunDep -> Bool Source # (<=) :: FunDep -> FunDep -> Bool Source # (>) :: FunDep -> FunDep -> Bool Source # (>=) :: FunDep -> FunDep -> Bool Source # max :: FunDep -> FunDep -> FunDep Source # min :: FunDep -> FunDep -> FunDep Source #
Ord InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering Source # (<) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (>) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool Source # max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn Source # min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn Source #
Ord Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Overlap -> Overlap -> Ordering Source # (<) :: Overlap -> Overlap -> Bool Source # (<=) :: Overlap -> Overlap -> Bool Source # (>) :: Overlap -> Overlap -> Bool Source # (>=) :: Overlap -> Overlap -> Bool Source # max :: Overlap -> Overlap -> Overlap Source # min :: Overlap -> Overlap -> Overlap Source #
Ord ()
Instance details Defined in GHC.Classes Methods compare :: () -> () -> Ordering Source # (<) :: () -> () -> Bool Source # (<=) :: () -> () -> Bool Source # (>) :: () -> () -> Bool Source # (>=) :: () -> () -> Bool Source # max :: () -> () -> () Source # min :: () -> () -> () Source #
Ord TyCon
Instance details Defined in GHC.Classes Methods compare :: TyCon -> TyCon -> Ordering Source # (<) :: TyCon -> TyCon -> Bool Source # (<=) :: TyCon -> TyCon -> Bool Source # (>) :: TyCon -> TyCon -> Bool Source # (>=) :: TyCon -> TyCon -> Bool Source # max :: TyCon -> TyCon -> TyCon Source # min :: TyCon -> TyCon -> TyCon Source #
Ord ByteString
Instance details Defined in Data.ByteString.Internal Methods compare :: ByteString -> ByteString -> Ordering Source # (<) :: ByteString -> ByteString -> Bool Source # (<=) :: ByteString -> ByteString -> Bool Source # (>) :: ByteString -> ByteString -> Bool Source # (>=) :: ByteString -> ByteString -> Bool Source # max :: ByteString -> ByteString -> ByteString Source # min :: ByteString -> ByteString -> ByteString Source #
Ord ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods compare :: ByteString -> ByteString -> Ordering Source # (<) :: ByteString -> ByteString -> Bool Source # (<=) :: ByteString -> ByteString -> Bool Source # (>) :: ByteString -> ByteString -> Bool Source # (>=) :: ByteString -> ByteString -> Bool Source # max :: ByteString -> ByteString -> ByteString Source # min :: ByteString -> ByteString -> ByteString Source #
Ord Builder
Instance details Defined in Data.Text.Internal.Builder Methods compare :: Builder -> Builder -> Ordering Source # (<) :: Builder -> Builder -> Bool Source # (<=) :: Builder -> Builder -> Bool Source # (>) :: Builder -> Builder -> Bool Source # (>=) :: Builder -> Builder -> Bool Source # max :: Builder -> Builder -> Builder Source # min :: Builder -> Builder -> Builder Source #
Ord Scientific	Scientific numbers can be safely compared for ordering. No magnitude `10^e` is calculated so there's no risk of a blowup in space or time when comparing scientific numbers coming from untrusted sources.
Instance details Defined in Data.Scientific Methods compare :: Scientific -> Scientific -> Ordering Source # (<) :: Scientific -> Scientific -> Bool Source # (<=) :: Scientific -> Scientific -> Bool Source # (>) :: Scientific -> Scientific -> Bool Source # (>=) :: Scientific -> Scientific -> Bool Source # max :: Scientific -> Scientific -> Scientific Source # min :: Scientific -> Scientific -> Scientific Source #
Ord UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods compare :: UTCTime -> UTCTime -> Ordering Source # (<) :: UTCTime -> UTCTime -> Bool Source # (<=) :: UTCTime -> UTCTime -> Bool Source # (>) :: UTCTime -> UTCTime -> Bool Source # (>=) :: UTCTime -> UTCTime -> Bool Source # max :: UTCTime -> UTCTime -> UTCTime Source # min :: UTCTime -> UTCTime -> UTCTime Source #
Ord JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: JSONPathElement -> JSONPathElement -> Ordering Source # (<) :: JSONPathElement -> JSONPathElement -> Bool Source # (<=) :: JSONPathElement -> JSONPathElement -> Bool Source # (>) :: JSONPathElement -> JSONPathElement -> Bool Source # (>=) :: JSONPathElement -> JSONPathElement -> Bool Source # max :: JSONPathElement -> JSONPathElement -> JSONPathElement Source # min :: JSONPathElement -> JSONPathElement -> JSONPathElement Source #
Ord Value	The ordering is total, consistent with `Eq` instance. However, nothing else about the ordering is specified, and it may change from environment to environment and version to version of either this package or its dependencies ( `hashable` and 'unordered-containers'). Since: aeson-1.5.2.0
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: Value -> Value -> Ordering Source # (<) :: Value -> Value -> Bool Source # (<=) :: Value -> Value -> Bool Source # (>) :: Value -> Value -> Bool Source # (>=) :: Value -> Value -> Bool Source # max :: Value -> Value -> Value Source # min :: Value -> Value -> Value Source #
Ord DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: DotNetTime -> DotNetTime -> Ordering Source # (<) :: DotNetTime -> DotNetTime -> Bool Source # (<=) :: DotNetTime -> DotNetTime -> Bool Source # (>) :: DotNetTime -> DotNetTime -> Bool Source # (>=) :: DotNetTime -> DotNetTime -> Bool Source # max :: DotNetTime -> DotNetTime -> DotNetTime Source # min :: DotNetTime -> DotNetTime -> DotNetTime Source #
Ord Key
Instance details Defined in Data.Aeson.Key Methods compare :: Key -> Key -> Ordering Source # (<) :: Key -> Key -> Bool Source # (<=) :: Key -> Key -> Bool Source # (>) :: Key -> Key -> Bool Source # (>=) :: Key -> Key -> Bool Source # max :: Key -> Key -> Key Source # min :: Key -> Key -> Key Source #
Ord ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: ThreadId -> ThreadId -> Ordering Source # (<) :: ThreadId -> ThreadId -> Bool Source # (<=) :: ThreadId -> ThreadId -> Bool Source # (>) :: ThreadId -> ThreadId -> Bool Source # (>=) :: ThreadId -> ThreadId -> Bool Source # max :: ThreadId -> ThreadId -> ThreadId Source # min :: ThreadId -> ThreadId -> ThreadId Source #
Ord Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods compare :: Pos -> Pos -> Ordering Source # (<) :: Pos -> Pos -> Bool Source # (<=) :: Pos -> Pos -> Bool Source # (>) :: Pos -> Pos -> Bool Source # (>=) :: Pos -> Pos -> Bool Source # max :: Pos -> Pos -> Pos Source # min :: Pos -> Pos -> Pos Source #
Ord Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods compare :: Void -> Void -> Ordering Source # (<) :: Void -> Void -> Bool Source # (<=) :: Void -> Void -> Bool Source # (>) :: Void -> Void -> Bool Source # (>=) :: Void -> Void -> Bool Source # max :: Void -> Void -> Void Source # min :: Void -> Void -> Void Source #
Ord Version	Since: base-2.1
Instance details Defined in Data.Version Methods compare :: Version -> Version -> Ordering Source # (<) :: Version -> Version -> Bool Source # (<=) :: Version -> Version -> Bool Source # (>) :: Version -> Version -> Bool Source # (>=) :: Version -> Version -> Bool Source # max :: Version -> Version -> Version Source # min :: Version -> Version -> Version Source #
Ord BlockReason	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: BlockReason -> BlockReason -> Ordering Source # (<) :: BlockReason -> BlockReason -> Bool Source # (<=) :: BlockReason -> BlockReason -> Bool Source # (>) :: BlockReason -> BlockReason -> Bool Source # (>=) :: BlockReason -> BlockReason -> Bool Source # max :: BlockReason -> BlockReason -> BlockReason Source # min :: BlockReason -> BlockReason -> BlockReason Source #
Ord ThreadStatus	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: ThreadStatus -> ThreadStatus -> Ordering Source # (<) :: ThreadStatus -> ThreadStatus -> Bool Source # (<=) :: ThreadStatus -> ThreadStatus -> Bool Source # (>) :: ThreadStatus -> ThreadStatus -> Bool Source # (>=) :: ThreadStatus -> ThreadStatus -> Bool Source # max :: ThreadStatus -> ThreadStatus -> ThreadStatus Source # min :: ThreadStatus -> ThreadStatus -> ThreadStatus Source #
Ord CDev
Instance details Defined in System.Posix.Types Methods compare :: CDev -> CDev -> Ordering Source # (<) :: CDev -> CDev -> Bool Source # (<=) :: CDev -> CDev -> Bool Source # (>) :: CDev -> CDev -> Bool Source # (>=) :: CDev -> CDev -> Bool Source # max :: CDev -> CDev -> CDev Source # min :: CDev -> CDev -> CDev Source #
Ord CIno
Instance details Defined in System.Posix.Types Methods compare :: CIno -> CIno -> Ordering Source # (<) :: CIno -> CIno -> Bool Source # (<=) :: CIno -> CIno -> Bool Source # (>) :: CIno -> CIno -> Bool Source # (>=) :: CIno -> CIno -> Bool Source # max :: CIno -> CIno -> CIno Source # min :: CIno -> CIno -> CIno Source #
Ord CMode
Instance details Defined in System.Posix.Types Methods compare :: CMode -> CMode -> Ordering Source # (<) :: CMode -> CMode -> Bool Source # (<=) :: CMode -> CMode -> Bool Source # (>) :: CMode -> CMode -> Bool Source # (>=) :: CMode -> CMode -> Bool Source # max :: CMode -> CMode -> CMode Source # min :: CMode -> CMode -> CMode Source #
Ord COff
Instance details Defined in System.Posix.Types Methods compare :: COff -> COff -> Ordering Source # (<) :: COff -> COff -> Bool Source # (<=) :: COff -> COff -> Bool Source # (>) :: COff -> COff -> Bool Source # (>=) :: COff -> COff -> Bool Source # max :: COff -> COff -> COff Source # min :: COff -> COff -> COff Source #
Ord CPid
Instance details Defined in System.Posix.Types Methods compare :: CPid -> CPid -> Ordering Source # (<) :: CPid -> CPid -> Bool Source # (<=) :: CPid -> CPid -> Bool Source # (>) :: CPid -> CPid -> Bool Source # (>=) :: CPid -> CPid -> Bool Source # max :: CPid -> CPid -> CPid Source # min :: CPid -> CPid -> CPid Source #
Ord CSsize
Instance details Defined in System.Posix.Types Methods compare :: CSsize -> CSsize -> Ordering Source # (<) :: CSsize -> CSsize -> Bool Source # (<=) :: CSsize -> CSsize -> Bool Source # (>) :: CSsize -> CSsize -> Bool Source # (>=) :: CSsize -> CSsize -> Bool Source # max :: CSsize -> CSsize -> CSsize Source # min :: CSsize -> CSsize -> CSsize Source #
Ord CGid
Instance details Defined in System.Posix.Types Methods compare :: CGid -> CGid -> Ordering Source # (<) :: CGid -> CGid -> Bool Source # (<=) :: CGid -> CGid -> Bool Source # (>) :: CGid -> CGid -> Bool Source # (>=) :: CGid -> CGid -> Bool Source # max :: CGid -> CGid -> CGid Source # min :: CGid -> CGid -> CGid Source #
Ord CNlink
Instance details Defined in System.Posix.Types Methods compare :: CNlink -> CNlink -> Ordering Source # (<) :: CNlink -> CNlink -> Bool Source # (<=) :: CNlink -> CNlink -> Bool Source # (>) :: CNlink -> CNlink -> Bool Source # (>=) :: CNlink -> CNlink -> Bool Source # max :: CNlink -> CNlink -> CNlink Source # min :: CNlink -> CNlink -> CNlink Source #
Ord CUid
Instance details Defined in System.Posix.Types Methods compare :: CUid -> CUid -> Ordering Source # (<) :: CUid -> CUid -> Bool Source # (<=) :: CUid -> CUid -> Bool Source # (>) :: CUid -> CUid -> Bool Source # (>=) :: CUid -> CUid -> Bool Source # max :: CUid -> CUid -> CUid Source # min :: CUid -> CUid -> CUid Source #
Ord CCc
Instance details Defined in System.Posix.Types Methods compare :: CCc -> CCc -> Ordering Source # (<) :: CCc -> CCc -> Bool Source # (<=) :: CCc -> CCc -> Bool Source # (>) :: CCc -> CCc -> Bool Source # (>=) :: CCc -> CCc -> Bool Source # max :: CCc -> CCc -> CCc Source # min :: CCc -> CCc -> CCc Source #
Ord CSpeed
Instance details Defined in System.Posix.Types Methods compare :: CSpeed -> CSpeed -> Ordering Source # (<) :: CSpeed -> CSpeed -> Bool Source # (<=) :: CSpeed -> CSpeed -> Bool Source # (>) :: CSpeed -> CSpeed -> Bool Source # (>=) :: CSpeed -> CSpeed -> Bool Source # max :: CSpeed -> CSpeed -> CSpeed Source # min :: CSpeed -> CSpeed -> CSpeed Source #
Ord CTcflag
Instance details Defined in System.Posix.Types Methods compare :: CTcflag -> CTcflag -> Ordering Source # (<) :: CTcflag -> CTcflag -> Bool Source # (<=) :: CTcflag -> CTcflag -> Bool Source # (>) :: CTcflag -> CTcflag -> Bool Source # (>=) :: CTcflag -> CTcflag -> Bool Source # max :: CTcflag -> CTcflag -> CTcflag Source # min :: CTcflag -> CTcflag -> CTcflag Source #
Ord CRLim
Instance details Defined in System.Posix.Types Methods compare :: CRLim -> CRLim -> Ordering Source # (<) :: CRLim -> CRLim -> Bool Source # (<=) :: CRLim -> CRLim -> Bool Source # (>) :: CRLim -> CRLim -> Bool Source # (>=) :: CRLim -> CRLim -> Bool Source # max :: CRLim -> CRLim -> CRLim Source # min :: CRLim -> CRLim -> CRLim Source #
Ord CBlkSize
Instance details Defined in System.Posix.Types Methods compare :: CBlkSize -> CBlkSize -> Ordering Source # (<) :: CBlkSize -> CBlkSize -> Bool Source # (<=) :: CBlkSize -> CBlkSize -> Bool Source # (>) :: CBlkSize -> CBlkSize -> Bool Source # (>=) :: CBlkSize -> CBlkSize -> Bool Source # max :: CBlkSize -> CBlkSize -> CBlkSize Source # min :: CBlkSize -> CBlkSize -> CBlkSize Source #
Ord CBlkCnt
Instance details Defined in System.Posix.Types Methods compare :: CBlkCnt -> CBlkCnt -> Ordering Source # (<) :: CBlkCnt -> CBlkCnt -> Bool Source # (<=) :: CBlkCnt -> CBlkCnt -> Bool Source # (>) :: CBlkCnt -> CBlkCnt -> Bool Source # (>=) :: CBlkCnt -> CBlkCnt -> Bool Source # max :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # min :: CBlkCnt -> CBlkCnt -> CBlkCnt Source #
Ord CClockId
Instance details Defined in System.Posix.Types Methods compare :: CClockId -> CClockId -> Ordering Source # (<) :: CClockId -> CClockId -> Bool Source # (<=) :: CClockId -> CClockId -> Bool Source # (>) :: CClockId -> CClockId -> Bool Source # (>=) :: CClockId -> CClockId -> Bool Source # max :: CClockId -> CClockId -> CClockId Source # min :: CClockId -> CClockId -> CClockId Source #
Ord CFsBlkCnt
Instance details Defined in System.Posix.Types Methods compare :: CFsBlkCnt -> CFsBlkCnt -> Ordering Source # (<) :: CFsBlkCnt -> CFsBlkCnt -> Bool Source # (<=) :: CFsBlkCnt -> CFsBlkCnt -> Bool Source # (>) :: CFsBlkCnt -> CFsBlkCnt -> Bool Source # (>=) :: CFsBlkCnt -> CFsBlkCnt -> Bool Source # max :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # min :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source #
Ord CFsFilCnt
Instance details Defined in System.Posix.Types Methods compare :: CFsFilCnt -> CFsFilCnt -> Ordering Source # (<) :: CFsFilCnt -> CFsFilCnt -> Bool Source # (<=) :: CFsFilCnt -> CFsFilCnt -> Bool Source # (>) :: CFsFilCnt -> CFsFilCnt -> Bool Source # (>=) :: CFsFilCnt -> CFsFilCnt -> Bool Source # max :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # min :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source #
Ord CId
Instance details Defined in System.Posix.Types Methods compare :: CId -> CId -> Ordering Source # (<) :: CId -> CId -> Bool Source # (<=) :: CId -> CId -> Bool Source # (>) :: CId -> CId -> Bool Source # (>=) :: CId -> CId -> Bool Source # max :: CId -> CId -> CId Source # min :: CId -> CId -> CId Source #
Ord CKey
Instance details Defined in System.Posix.Types Methods compare :: CKey -> CKey -> Ordering Source # (<) :: CKey -> CKey -> Bool Source # (<=) :: CKey -> CKey -> Bool Source # (>) :: CKey -> CKey -> Bool Source # (>=) :: CKey -> CKey -> Bool Source # max :: CKey -> CKey -> CKey Source # min :: CKey -> CKey -> CKey Source #
Ord CSocklen
Instance details Defined in System.Posix.Types Methods compare :: CSocklen -> CSocklen -> Ordering Source # (<) :: CSocklen -> CSocklen -> Bool Source # (<=) :: CSocklen -> CSocklen -> Bool Source # (>) :: CSocklen -> CSocklen -> Bool Source # (>=) :: CSocklen -> CSocklen -> Bool Source # max :: CSocklen -> CSocklen -> CSocklen Source # min :: CSocklen -> CSocklen -> CSocklen Source #
Ord CNfds
Instance details Defined in System.Posix.Types Methods compare :: CNfds -> CNfds -> Ordering Source # (<) :: CNfds -> CNfds -> Bool Source # (<=) :: CNfds -> CNfds -> Bool Source # (>) :: CNfds -> CNfds -> Bool Source # (>=) :: CNfds -> CNfds -> Bool Source # max :: CNfds -> CNfds -> CNfds Source # min :: CNfds -> CNfds -> CNfds Source #
Ord Fd
Instance details Defined in System.Posix.Types Methods compare :: Fd -> Fd -> Ordering Source # (<) :: Fd -> Fd -> Bool Source # (<=) :: Fd -> Fd -> Bool Source # (>) :: Fd -> Fd -> Bool Source # (>=) :: Fd -> Fd -> Bool Source # max :: Fd -> Fd -> Fd Source # min :: Fd -> Fd -> Fd Source #
Ord AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering Source # (<) :: AsyncException -> AsyncException -> Bool Source # (<=) :: AsyncException -> AsyncException -> Bool Source # (>) :: AsyncException -> AsyncException -> Bool Source # (>=) :: AsyncException -> AsyncException -> Bool Source # max :: AsyncException -> AsyncException -> AsyncException Source # min :: AsyncException -> AsyncException -> AsyncException Source #
Ord ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering Source # (<) :: ArrayException -> ArrayException -> Bool Source # (<=) :: ArrayException -> ArrayException -> Bool Source # (>) :: ArrayException -> ArrayException -> Bool Source # (>=) :: ArrayException -> ArrayException -> Bool Source # max :: ArrayException -> ArrayException -> ArrayException Source # min :: ArrayException -> ArrayException -> ArrayException Source #
Ord ExitCode
Instance details Defined in GHC.IO.Exception Methods compare :: ExitCode -> ExitCode -> Ordering Source # (<) :: ExitCode -> ExitCode -> Bool Source # (<=) :: ExitCode -> ExitCode -> Bool Source # (>) :: ExitCode -> ExitCode -> Bool Source # (>=) :: ExitCode -> ExitCode -> Bool Source # max :: ExitCode -> ExitCode -> ExitCode Source # min :: ExitCode -> ExitCode -> ExitCode Source #
Ord BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods compare :: BufferMode -> BufferMode -> Ordering Source # (<) :: BufferMode -> BufferMode -> Bool Source # (<=) :: BufferMode -> BufferMode -> Bool Source # (>) :: BufferMode -> BufferMode -> Bool Source # (>=) :: BufferMode -> BufferMode -> Bool Source # max :: BufferMode -> BufferMode -> BufferMode Source # min :: BufferMode -> BufferMode -> BufferMode Source #
Ord Newline	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods compare :: Newline -> Newline -> Ordering Source # (<) :: Newline -> Newline -> Bool Source # (<=) :: Newline -> Newline -> Bool Source # (>) :: Newline -> Newline -> Bool Source # (>=) :: Newline -> Newline -> Bool Source # max :: Newline -> Newline -> Newline Source # min :: Newline -> Newline -> Newline Source #
Ord NewlineMode	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods compare :: NewlineMode -> NewlineMode -> Ordering Source # (<) :: NewlineMode -> NewlineMode -> Bool Source # (<=) :: NewlineMode -> NewlineMode -> Bool Source # (>) :: NewlineMode -> NewlineMode -> Bool Source # (>=) :: NewlineMode -> NewlineMode -> Bool Source # max :: NewlineMode -> NewlineMode -> NewlineMode Source # min :: NewlineMode -> NewlineMode -> NewlineMode Source #
Ord ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods compare :: ErrorCall -> ErrorCall -> Ordering Source # (<) :: ErrorCall -> ErrorCall -> Bool Source # (<=) :: ErrorCall -> ErrorCall -> Bool Source # (>) :: ErrorCall -> ErrorCall -> Bool Source # (>=) :: ErrorCall -> ErrorCall -> Bool Source # max :: ErrorCall -> ErrorCall -> ErrorCall Source # min :: ErrorCall -> ErrorCall -> ErrorCall Source #
Ord ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering Source # (<) :: ArithException -> ArithException -> Bool Source # (<=) :: ArithException -> ArithException -> Bool Source # (>) :: ArithException -> ArithException -> Bool Source # (>=) :: ArithException -> ArithException -> Bool Source # max :: ArithException -> ArithException -> ArithException Source # min :: ArithException -> ArithException -> ArithException Source #
Ord All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: All -> All -> Ordering Source # (<) :: All -> All -> Bool Source # (<=) :: All -> All -> Bool Source # (>) :: All -> All -> Bool Source # (>=) :: All -> All -> Bool Source # max :: All -> All -> All Source # min :: All -> All -> All Source #
Ord Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Any -> Any -> Ordering Source # (<) :: Any -> Any -> Bool Source # (<=) :: Any -> Any -> Bool Source # (>) :: Any -> Any -> Bool Source # (>=) :: Any -> Any -> Bool Source # max :: Any -> Any -> Any Source # min :: Any -> Any -> Any Source #
Ord Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Fixity -> Fixity -> Ordering Source # (<) :: Fixity -> Fixity -> Bool Source # (<=) :: Fixity -> Fixity -> Bool Source # (>) :: Fixity -> Fixity -> Bool Source # (>=) :: Fixity -> Fixity -> Bool Source # max :: Fixity -> Fixity -> Fixity Source # min :: Fixity -> Fixity -> Fixity Source #
Ord Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering Source # (<) :: Associativity -> Associativity -> Bool Source # (<=) :: Associativity -> Associativity -> Bool Source # (>) :: Associativity -> Associativity -> Bool Source # (>=) :: Associativity -> Associativity -> Bool Source # max :: Associativity -> Associativity -> Associativity Source # min :: Associativity -> Associativity -> Associativity Source #
Ord SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering Source # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source #
Ord SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering Source # (<) :: SourceStrictness -> SourceStrictness -> Bool Source # (<=) :: SourceStrictness -> SourceStrictness -> Bool Source # (>) :: SourceStrictness -> SourceStrictness -> Bool Source # (>=) :: SourceStrictness -> SourceStrictness -> Bool Source # max :: SourceStrictness -> SourceStrictness -> SourceStrictness Source # min :: SourceStrictness -> SourceStrictness -> SourceStrictness Source #
Ord DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering Source # (<) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source #
Ord SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods compare :: SomeSymbol -> SomeSymbol -> Ordering Source # (<) :: SomeSymbol -> SomeSymbol -> Bool Source # (<=) :: SomeSymbol -> SomeSymbol -> Bool Source # (>) :: SomeSymbol -> SomeSymbol -> Bool Source # (>=) :: SomeSymbol -> SomeSymbol -> Bool Source # max :: SomeSymbol -> SomeSymbol -> SomeSymbol Source # min :: SomeSymbol -> SomeSymbol -> SomeSymbol Source #
Ord SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods compare :: SomeNat -> SomeNat -> Ordering Source # (<) :: SomeNat -> SomeNat -> Bool Source # (<=) :: SomeNat -> SomeNat -> Bool Source # (>) :: SomeNat -> SomeNat -> Bool Source # (>=) :: SomeNat -> SomeNat -> Bool Source # max :: SomeNat -> SomeNat -> SomeNat Source # min :: SomeNat -> SomeNat -> SomeNat Source #
Ord CChar
Instance details Defined in Foreign.C.Types Methods compare :: CChar -> CChar -> Ordering Source # (<) :: CChar -> CChar -> Bool Source # (<=) :: CChar -> CChar -> Bool Source # (>) :: CChar -> CChar -> Bool Source # (>=) :: CChar -> CChar -> Bool Source # max :: CChar -> CChar -> CChar Source # min :: CChar -> CChar -> CChar Source #
Ord CSChar
Instance details Defined in Foreign.C.Types Methods compare :: CSChar -> CSChar -> Ordering Source # (<) :: CSChar -> CSChar -> Bool Source # (<=) :: CSChar -> CSChar -> Bool Source # (>) :: CSChar -> CSChar -> Bool Source # (>=) :: CSChar -> CSChar -> Bool Source # max :: CSChar -> CSChar -> CSChar Source # min :: CSChar -> CSChar -> CSChar Source #
Ord CUChar
Instance details Defined in Foreign.C.Types Methods compare :: CUChar -> CUChar -> Ordering Source # (<) :: CUChar -> CUChar -> Bool Source # (<=) :: CUChar -> CUChar -> Bool Source # (>) :: CUChar -> CUChar -> Bool Source # (>=) :: CUChar -> CUChar -> Bool Source # max :: CUChar -> CUChar -> CUChar Source # min :: CUChar -> CUChar -> CUChar Source #
Ord CShort
Instance details Defined in Foreign.C.Types Methods compare :: CShort -> CShort -> Ordering Source # (<) :: CShort -> CShort -> Bool Source # (<=) :: CShort -> CShort -> Bool Source # (>) :: CShort -> CShort -> Bool Source # (>=) :: CShort -> CShort -> Bool Source # max :: CShort -> CShort -> CShort Source # min :: CShort -> CShort -> CShort Source #
Ord CUShort
Instance details Defined in Foreign.C.Types Methods compare :: CUShort -> CUShort -> Ordering Source # (<) :: CUShort -> CUShort -> Bool Source # (<=) :: CUShort -> CUShort -> Bool Source # (>) :: CUShort -> CUShort -> Bool Source # (>=) :: CUShort -> CUShort -> Bool Source # max :: CUShort -> CUShort -> CUShort Source # min :: CUShort -> CUShort -> CUShort Source #
Ord CInt
Instance details Defined in Foreign.C.Types Methods compare :: CInt -> CInt -> Ordering Source # (<) :: CInt -> CInt -> Bool Source # (<=) :: CInt -> CInt -> Bool Source # (>) :: CInt -> CInt -> Bool Source # (>=) :: CInt -> CInt -> Bool Source # max :: CInt -> CInt -> CInt Source # min :: CInt -> CInt -> CInt Source #
Ord CUInt
Instance details Defined in Foreign.C.Types Methods compare :: CUInt -> CUInt -> Ordering Source # (<) :: CUInt -> CUInt -> Bool Source # (<=) :: CUInt -> CUInt -> Bool Source # (>) :: CUInt -> CUInt -> Bool Source # (>=) :: CUInt -> CUInt -> Bool Source # max :: CUInt -> CUInt -> CUInt Source # min :: CUInt -> CUInt -> CUInt Source #
Ord CLong
Instance details Defined in Foreign.C.Types Methods compare :: CLong -> CLong -> Ordering Source # (<) :: CLong -> CLong -> Bool Source # (<=) :: CLong -> CLong -> Bool Source # (>) :: CLong -> CLong -> Bool Source # (>=) :: CLong -> CLong -> Bool Source # max :: CLong -> CLong -> CLong Source # min :: CLong -> CLong -> CLong Source #
Ord CULong
Instance details Defined in Foreign.C.Types Methods compare :: CULong -> CULong -> Ordering Source # (<) :: CULong -> CULong -> Bool Source # (<=) :: CULong -> CULong -> Bool Source # (>) :: CULong -> CULong -> Bool Source # (>=) :: CULong -> CULong -> Bool Source # max :: CULong -> CULong -> CULong Source # min :: CULong -> CULong -> CULong Source #
Ord CLLong
Instance details Defined in Foreign.C.Types Methods compare :: CLLong -> CLLong -> Ordering Source # (<) :: CLLong -> CLLong -> Bool Source # (<=) :: CLLong -> CLLong -> Bool Source # (>) :: CLLong -> CLLong -> Bool Source # (>=) :: CLLong -> CLLong -> Bool Source # max :: CLLong -> CLLong -> CLLong Source # min :: CLLong -> CLLong -> CLLong Source #
Ord CULLong
Instance details Defined in Foreign.C.Types Methods compare :: CULLong -> CULLong -> Ordering Source # (<) :: CULLong -> CULLong -> Bool Source # (<=) :: CULLong -> CULLong -> Bool Source # (>) :: CULLong -> CULLong -> Bool Source # (>=) :: CULLong -> CULLong -> Bool Source # max :: CULLong -> CULLong -> CULLong Source # min :: CULLong -> CULLong -> CULLong Source #
Ord CBool
Instance details Defined in Foreign.C.Types Methods compare :: CBool -> CBool -> Ordering Source # (<) :: CBool -> CBool -> Bool Source # (<=) :: CBool -> CBool -> Bool Source # (>) :: CBool -> CBool -> Bool Source # (>=) :: CBool -> CBool -> Bool Source # max :: CBool -> CBool -> CBool Source # min :: CBool -> CBool -> CBool Source #
Ord CFloat
Instance details Defined in Foreign.C.Types Methods compare :: CFloat -> CFloat -> Ordering Source # (<) :: CFloat -> CFloat -> Bool Source # (<=) :: CFloat -> CFloat -> Bool Source # (>) :: CFloat -> CFloat -> Bool Source # (>=) :: CFloat -> CFloat -> Bool Source # max :: CFloat -> CFloat -> CFloat Source # min :: CFloat -> CFloat -> CFloat Source #
Ord CDouble
Instance details Defined in Foreign.C.Types Methods compare :: CDouble -> CDouble -> Ordering Source # (<) :: CDouble -> CDouble -> Bool Source # (<=) :: CDouble -> CDouble -> Bool Source # (>) :: CDouble -> CDouble -> Bool Source # (>=) :: CDouble -> CDouble -> Bool Source # max :: CDouble -> CDouble -> CDouble Source # min :: CDouble -> CDouble -> CDouble Source #
Ord CPtrdiff
Instance details Defined in Foreign.C.Types Methods compare :: CPtrdiff -> CPtrdiff -> Ordering Source # (<) :: CPtrdiff -> CPtrdiff -> Bool Source # (<=) :: CPtrdiff -> CPtrdiff -> Bool Source # (>) :: CPtrdiff -> CPtrdiff -> Bool Source # (>=) :: CPtrdiff -> CPtrdiff -> Bool Source # max :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # min :: CPtrdiff -> CPtrdiff -> CPtrdiff Source #
Ord CSize
Instance details Defined in Foreign.C.Types Methods compare :: CSize -> CSize -> Ordering Source # (<) :: CSize -> CSize -> Bool Source # (<=) :: CSize -> CSize -> Bool Source # (>) :: CSize -> CSize -> Bool Source # (>=) :: CSize -> CSize -> Bool Source # max :: CSize -> CSize -> CSize Source # min :: CSize -> CSize -> CSize Source #
Ord CWchar
Instance details Defined in Foreign.C.Types Methods compare :: CWchar -> CWchar -> Ordering Source # (<) :: CWchar -> CWchar -> Bool Source # (<=) :: CWchar -> CWchar -> Bool Source # (>) :: CWchar -> CWchar -> Bool Source # (>=) :: CWchar -> CWchar -> Bool Source # max :: CWchar -> CWchar -> CWchar Source # min :: CWchar -> CWchar -> CWchar Source #
Ord CSigAtomic
Instance details Defined in Foreign.C.Types Methods compare :: CSigAtomic -> CSigAtomic -> Ordering Source # (<) :: CSigAtomic -> CSigAtomic -> Bool Source # (<=) :: CSigAtomic -> CSigAtomic -> Bool Source # (>) :: CSigAtomic -> CSigAtomic -> Bool Source # (>=) :: CSigAtomic -> CSigAtomic -> Bool Source # max :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # min :: CSigAtomic -> CSigAtomic -> CSigAtomic Source #
Ord CClock
Instance details Defined in Foreign.C.Types Methods compare :: CClock -> CClock -> Ordering Source # (<) :: CClock -> CClock -> Bool Source # (<=) :: CClock -> CClock -> Bool Source # (>) :: CClock -> CClock -> Bool Source # (>=) :: CClock -> CClock -> Bool Source # max :: CClock -> CClock -> CClock Source # min :: CClock -> CClock -> CClock Source #
Ord CTime
Instance details Defined in Foreign.C.Types Methods compare :: CTime -> CTime -> Ordering Source # (<) :: CTime -> CTime -> Bool Source # (<=) :: CTime -> CTime -> Bool Source # (>) :: CTime -> CTime -> Bool Source # (>=) :: CTime -> CTime -> Bool Source # max :: CTime -> CTime -> CTime Source # min :: CTime -> CTime -> CTime Source #
Ord CUSeconds
Instance details Defined in Foreign.C.Types Methods compare :: CUSeconds -> CUSeconds -> Ordering Source # (<) :: CUSeconds -> CUSeconds -> Bool Source # (<=) :: CUSeconds -> CUSeconds -> Bool Source # (>) :: CUSeconds -> CUSeconds -> Bool Source # (>=) :: CUSeconds -> CUSeconds -> Bool Source # max :: CUSeconds -> CUSeconds -> CUSeconds Source # min :: CUSeconds -> CUSeconds -> CUSeconds Source #
Ord CSUSeconds
Instance details Defined in Foreign.C.Types Methods compare :: CSUSeconds -> CSUSeconds -> Ordering Source # (<) :: CSUSeconds -> CSUSeconds -> Bool Source # (<=) :: CSUSeconds -> CSUSeconds -> Bool Source # (>) :: CSUSeconds -> CSUSeconds -> Bool Source # (>=) :: CSUSeconds -> CSUSeconds -> Bool Source # max :: CSUSeconds -> CSUSeconds -> CSUSeconds Source # min :: CSUSeconds -> CSUSeconds -> CSUSeconds Source #
Ord CIntPtr
Instance details Defined in Foreign.C.Types Methods compare :: CIntPtr -> CIntPtr -> Ordering Source # (<) :: CIntPtr -> CIntPtr -> Bool Source # (<=) :: CIntPtr -> CIntPtr -> Bool Source # (>) :: CIntPtr -> CIntPtr -> Bool Source # (>=) :: CIntPtr -> CIntPtr -> Bool Source # max :: CIntPtr -> CIntPtr -> CIntPtr Source # min :: CIntPtr -> CIntPtr -> CIntPtr Source #
Ord CUIntPtr
Instance details Defined in Foreign.C.Types Methods compare :: CUIntPtr -> CUIntPtr -> Ordering Source # (<) :: CUIntPtr -> CUIntPtr -> Bool Source # (<=) :: CUIntPtr -> CUIntPtr -> Bool Source # (>) :: CUIntPtr -> CUIntPtr -> Bool Source # (>=) :: CUIntPtr -> CUIntPtr -> Bool Source # max :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # min :: CUIntPtr -> CUIntPtr -> CUIntPtr Source #
Ord CIntMax
Instance details Defined in Foreign.C.Types Methods compare :: CIntMax -> CIntMax -> Ordering Source # (<) :: CIntMax -> CIntMax -> Bool Source # (<=) :: CIntMax -> CIntMax -> Bool Source # (>) :: CIntMax -> CIntMax -> Bool Source # (>=) :: CIntMax -> CIntMax -> Bool Source # max :: CIntMax -> CIntMax -> CIntMax Source # min :: CIntMax -> CIntMax -> CIntMax Source #
Ord CUIntMax
Instance details Defined in Foreign.C.Types Methods compare :: CUIntMax -> CUIntMax -> Ordering Source # (<) :: CUIntMax -> CUIntMax -> Bool Source # (<=) :: CUIntMax -> CUIntMax -> Bool Source # (>) :: CUIntMax -> CUIntMax -> Bool Source # (>=) :: CUIntMax -> CUIntMax -> Bool Source # max :: CUIntMax -> CUIntMax -> CUIntMax Source # min :: CUIntMax -> CUIntMax -> CUIntMax Source #
Ord WordPtr
Instance details Defined in Foreign.Ptr Methods compare :: WordPtr -> WordPtr -> Ordering Source # (<) :: WordPtr -> WordPtr -> Bool Source # (<=) :: WordPtr -> WordPtr -> Bool Source # (>) :: WordPtr -> WordPtr -> Bool Source # (>=) :: WordPtr -> WordPtr -> Bool Source # max :: WordPtr -> WordPtr -> WordPtr Source # min :: WordPtr -> WordPtr -> WordPtr Source #
Ord IntPtr
Instance details Defined in Foreign.Ptr Methods compare :: IntPtr -> IntPtr -> Ordering Source # (<) :: IntPtr -> IntPtr -> Bool Source # (<=) :: IntPtr -> IntPtr -> Bool Source # (>) :: IntPtr -> IntPtr -> Bool Source # (>=) :: IntPtr -> IntPtr -> Bool Source # max :: IntPtr -> IntPtr -> IntPtr Source # min :: IntPtr -> IntPtr -> IntPtr Source #
Ord IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods compare :: IOMode -> IOMode -> Ordering Source # (<) :: IOMode -> IOMode -> Bool Source # (<=) :: IOMode -> IOMode -> Bool Source # (>) :: IOMode -> IOMode -> Bool Source # (>=) :: IOMode -> IOMode -> Bool Source # max :: IOMode -> IOMode -> IOMode Source # min :: IOMode -> IOMode -> IOMode Source #
Ord GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering Source # (<) :: GeneralCategory -> GeneralCategory -> Bool Source # (<=) :: GeneralCategory -> GeneralCategory -> Bool Source # (>) :: GeneralCategory -> GeneralCategory -> Bool Source # (>=) :: GeneralCategory -> GeneralCategory -> Bool Source # max :: GeneralCategory -> GeneralCategory -> GeneralCategory Source # min :: GeneralCategory -> GeneralCategory -> GeneralCategory Source #
Ord ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods compare :: ShortByteString -> ShortByteString -> Ordering Source # (<) :: ShortByteString -> ShortByteString -> Bool Source # (<=) :: ShortByteString -> ShortByteString -> Bool Source # (>) :: ShortByteString -> ShortByteString -> Bool Source # (>=) :: ShortByteString -> ShortByteString -> Bool Source # max :: ShortByteString -> ShortByteString -> ShortByteString Source # min :: ShortByteString -> ShortByteString -> ShortByteString Source #
Ord JSValue
Instance details Defined in Text.JSON.Canonical.Types Methods compare :: JSValue -> JSValue -> Ordering Source # (<) :: JSValue -> JSValue -> Bool Source # (<=) :: JSValue -> JSValue -> Bool Source # (>) :: JSValue -> JSValue -> Bool Source # (>=) :: JSValue -> JSValue -> Bool Source # max :: JSValue -> JSValue -> JSValue Source # min :: JSValue -> JSValue -> JSValue Source #
Ord JSString
Instance details Defined in Text.JSON.Canonical.Types Methods compare :: JSString -> JSString -> Ordering Source # (<) :: JSString -> JSString -> Bool Source # (<=) :: JSString -> JSString -> Bool Source # (>) :: JSString -> JSString -> Bool Source # (>=) :: JSString -> JSString -> Bool Source # max :: JSString -> JSString -> JSString Source # min :: JSString -> JSString -> JSString Source #
Ord Int54
Instance details Defined in Text.JSON.Canonical.Types Methods compare :: Int54 -> Int54 -> Ordering Source # (<) :: Int54 -> Int54 -> Bool Source # (<=) :: Int54 -> Int54 -> Bool Source # (>) :: Int54 -> Int54 -> Bool Source # (>=) :: Int54 -> Int54 -> Bool Source # max :: Int54 -> Int54 -> Int54 Source # min :: Int54 -> Int54 -> Int54 Source #
Ord ByteArray	Non-lexicographic ordering. This compares the lengths of the byte arrays first and uses a lexicographic ordering if the lengths are equal. Subject to change between major versions. Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.ByteArray Methods compare :: ByteArray -> ByteArray -> Ordering Source # (<) :: ByteArray -> ByteArray -> Bool Source # (<=) :: ByteArray -> ByteArray -> Bool Source # (>) :: ByteArray -> ByteArray -> Bool Source # (>=) :: ByteArray -> ByteArray -> Bool Source # max :: ByteArray -> ByteArray -> ByteArray Source # min :: ByteArray -> ByteArray -> ByteArray Source #
Ord TokenType
Instance details Defined in Codec.CBOR.Decoding Methods compare :: TokenType -> TokenType -> Ordering Source # (<) :: TokenType -> TokenType -> Bool Source # (<=) :: TokenType -> TokenType -> Bool Source # (>) :: TokenType -> TokenType -> Bool Source # (>=) :: TokenType -> TokenType -> Bool Source # max :: TokenType -> TokenType -> TokenType Source # min :: TokenType -> TokenType -> TokenType Source #
Ord ByteArray
Instance details Defined in Codec.CBOR.ByteArray Methods compare :: ByteArray -> ByteArray -> Ordering Source # (<) :: ByteArray -> ByteArray -> Bool Source # (<=) :: ByteArray -> ByteArray -> Bool Source # (>) :: ByteArray -> ByteArray -> Bool Source # (>=) :: ByteArray -> ByteArray -> Bool Source # max :: ByteArray -> ByteArray -> ByteArray Source # min :: ByteArray -> ByteArray -> ByteArray Source #
Ord SlicedByteArray
Instance details Defined in Codec.CBOR.ByteArray.Sliced Methods compare :: SlicedByteArray -> SlicedByteArray -> Ordering Source # (<) :: SlicedByteArray -> SlicedByteArray -> Bool Source # (<=) :: SlicedByteArray -> SlicedByteArray -> Bool Source # (>) :: SlicedByteArray -> SlicedByteArray -> Bool Source # (>=) :: SlicedByteArray -> SlicedByteArray -> Bool Source # max :: SlicedByteArray -> SlicedByteArray -> SlicedByteArray Source # min :: SlicedByteArray -> SlicedByteArray -> SlicedByteArray Source #
Ord IntSet
Instance details Defined in Data.IntSet.Internal Methods compare :: IntSet -> IntSet -> Ordering Source # (<) :: IntSet -> IntSet -> Bool Source # (<=) :: IntSet -> IntSet -> Bool Source # (>) :: IntSet -> IntSet -> Bool Source # (>=) :: IntSet -> IntSet -> Bool Source # max :: IntSet -> IntSet -> IntSet Source # min :: IntSet -> IntSet -> IntSet Source #
Ord DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods compare :: DiffTime -> DiffTime -> Ordering Source # (<) :: DiffTime -> DiffTime -> Bool Source # (<=) :: DiffTime -> DiffTime -> Bool Source # (>) :: DiffTime -> DiffTime -> Bool Source # (>=) :: DiffTime -> DiffTime -> Bool Source # max :: DiffTime -> DiffTime -> DiffTime Source # min :: DiffTime -> DiffTime -> DiffTime Source #
Ord NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods compare :: NominalDiffTime -> NominalDiffTime -> Ordering Source # (<) :: NominalDiffTime -> NominalDiffTime -> Bool Source # (<=) :: NominalDiffTime -> NominalDiffTime -> Bool Source # (>) :: NominalDiffTime -> NominalDiffTime -> Bool Source # (>=) :: NominalDiffTime -> NominalDiffTime -> Bool Source # max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime Source # min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime Source #
Ord ClosureType
Instance details Defined in GHC.Exts.Heap.ClosureTypes Methods compare :: ClosureType -> ClosureType -> Ordering Source # (<) :: ClosureType -> ClosureType -> Bool Source # (<=) :: ClosureType -> ClosureType -> Bool Source # (>) :: ClosureType -> ClosureType -> Bool Source # (>=) :: ClosureType -> ClosureType -> Bool Source # max :: ClosureType -> ClosureType -> ClosureType Source # min :: ClosureType -> ClosureType -> ClosureType Source #
Ord BigNat
Instance details Defined in GHC.Integer.Type Methods compare :: BigNat -> BigNat -> Ordering Source # (<) :: BigNat -> BigNat -> Bool Source # (<=) :: BigNat -> BigNat -> Bool Source # (>) :: BigNat -> BigNat -> Bool Source # (>=) :: BigNat -> BigNat -> Bool Source # max :: BigNat -> BigNat -> BigNat Source # min :: BigNat -> BigNat -> BigNat Source #
Ord ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: ModName -> ModName -> Ordering Source # (<) :: ModName -> ModName -> Bool Source # (<=) :: ModName -> ModName -> Bool Source # (>) :: ModName -> ModName -> Bool Source # (>=) :: ModName -> ModName -> Bool Source # max :: ModName -> ModName -> ModName Source # min :: ModName -> ModName -> ModName Source #
Ord PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PkgName -> PkgName -> Ordering Source # (<) :: PkgName -> PkgName -> Bool Source # (<=) :: PkgName -> PkgName -> Bool Source # (>) :: PkgName -> PkgName -> Bool Source # (>=) :: PkgName -> PkgName -> Bool Source # max :: PkgName -> PkgName -> PkgName Source # min :: PkgName -> PkgName -> PkgName Source #
Ord Module
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Module -> Module -> Ordering Source # (<) :: Module -> Module -> Bool Source # (<=) :: Module -> Module -> Bool Source # (>) :: Module -> Module -> Bool Source # (>=) :: Module -> Module -> Bool Source # max :: Module -> Module -> Module Source # min :: Module -> Module -> Module Source #
Ord OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: OccName -> OccName -> Ordering Source # (<) :: OccName -> OccName -> Bool Source # (<=) :: OccName -> OccName -> Bool Source # (>) :: OccName -> OccName -> Bool Source # (>=) :: OccName -> OccName -> Bool Source # max :: OccName -> OccName -> OccName Source # min :: OccName -> OccName -> OccName Source #
Ord NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: NameFlavour -> NameFlavour -> Ordering Source # (<) :: NameFlavour -> NameFlavour -> Bool Source # (<=) :: NameFlavour -> NameFlavour -> Bool Source # (>) :: NameFlavour -> NameFlavour -> Bool Source # (>=) :: NameFlavour -> NameFlavour -> Bool Source # max :: NameFlavour -> NameFlavour -> NameFlavour Source # min :: NameFlavour -> NameFlavour -> NameFlavour Source #
Ord NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: NameSpace -> NameSpace -> Ordering Source # (<) :: NameSpace -> NameSpace -> Bool Source # (<=) :: NameSpace -> NameSpace -> Bool Source # (>) :: NameSpace -> NameSpace -> Bool Source # (>=) :: NameSpace -> NameSpace -> Bool Source # max :: NameSpace -> NameSpace -> NameSpace Source # min :: NameSpace -> NameSpace -> NameSpace Source #
Ord Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Loc -> Loc -> Ordering Source # (<) :: Loc -> Loc -> Bool Source # (<=) :: Loc -> Loc -> Bool Source # (>) :: Loc -> Loc -> Bool Source # (>=) :: Loc -> Loc -> Bool Source # max :: Loc -> Loc -> Loc Source # min :: Loc -> Loc -> Loc Source #
Ord Info
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Info -> Info -> Ordering Source # (<) :: Info -> Info -> Bool Source # (<=) :: Info -> Info -> Bool Source # (>) :: Info -> Info -> Bool Source # (>=) :: Info -> Info -> Bool Source # max :: Info -> Info -> Info Source # min :: Info -> Info -> Info Source #
Ord ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: ModuleInfo -> ModuleInfo -> Ordering Source # (<) :: ModuleInfo -> ModuleInfo -> Bool Source # (<=) :: ModuleInfo -> ModuleInfo -> Bool Source # (>) :: ModuleInfo -> ModuleInfo -> Bool Source # (>=) :: ModuleInfo -> ModuleInfo -> Bool Source # max :: ModuleInfo -> ModuleInfo -> ModuleInfo Source # min :: ModuleInfo -> ModuleInfo -> ModuleInfo Source #
Ord Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Fixity -> Fixity -> Ordering Source # (<) :: Fixity -> Fixity -> Bool Source # (<=) :: Fixity -> Fixity -> Bool Source # (>) :: Fixity -> Fixity -> Bool Source # (>=) :: Fixity -> Fixity -> Bool Source # max :: Fixity -> Fixity -> Fixity Source # min :: Fixity -> Fixity -> Fixity Source #
Ord FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering Source # (<) :: FixityDirection -> FixityDirection -> Bool Source # (<=) :: FixityDirection -> FixityDirection -> Bool Source # (>) :: FixityDirection -> FixityDirection -> Bool Source # (>=) :: FixityDirection -> FixityDirection -> Bool Source # max :: FixityDirection -> FixityDirection -> FixityDirection Source # min :: FixityDirection -> FixityDirection -> FixityDirection Source #
Ord Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Lit -> Lit -> Ordering Source # (<) :: Lit -> Lit -> Bool Source # (<=) :: Lit -> Lit -> Bool Source # (>) :: Lit -> Lit -> Bool Source # (>=) :: Lit -> Lit -> Bool Source # max :: Lit -> Lit -> Lit Source # min :: Lit -> Lit -> Lit Source #
Ord Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Bytes -> Bytes -> Ordering Source # (<) :: Bytes -> Bytes -> Bool Source # (<=) :: Bytes -> Bytes -> Bool Source # (>) :: Bytes -> Bytes -> Bool Source # (>=) :: Bytes -> Bytes -> Bool Source # max :: Bytes -> Bytes -> Bytes Source # min :: Bytes -> Bytes -> Bytes Source #
Ord Body
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Body -> Body -> Ordering Source # (<) :: Body -> Body -> Bool Source # (<=) :: Body -> Body -> Bool Source # (>) :: Body -> Body -> Bool Source # (>=) :: Body -> Body -> Bool Source # max :: Body -> Body -> Body Source # min :: Body -> Body -> Body Source #
Ord Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Guard -> Guard -> Ordering Source # (<) :: Guard -> Guard -> Bool Source # (<=) :: Guard -> Guard -> Bool Source # (>) :: Guard -> Guard -> Bool Source # (>=) :: Guard -> Guard -> Bool Source # max :: Guard -> Guard -> Guard Source # min :: Guard -> Guard -> Guard Source #
Ord Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Stmt -> Stmt -> Ordering Source # (<) :: Stmt -> Stmt -> Bool Source # (<=) :: Stmt -> Stmt -> Bool Source # (>) :: Stmt -> Stmt -> Bool Source # (>=) :: Stmt -> Stmt -> Bool Source # max :: Stmt -> Stmt -> Stmt Source # min :: Stmt -> Stmt -> Stmt Source #
Ord Range
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Range -> Range -> Ordering Source # (<) :: Range -> Range -> Bool Source # (<=) :: Range -> Range -> Bool Source # (>) :: Range -> Range -> Bool Source # (>=) :: Range -> Range -> Bool Source # max :: Range -> Range -> Range Source # min :: Range -> Range -> Range Source #
Ord DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DerivClause -> DerivClause -> Ordering Source # (<) :: DerivClause -> DerivClause -> Bool Source # (<=) :: DerivClause -> DerivClause -> Bool Source # (>) :: DerivClause -> DerivClause -> Bool Source # (>=) :: DerivClause -> DerivClause -> Bool Source # max :: DerivClause -> DerivClause -> DerivClause Source # min :: DerivClause -> DerivClause -> DerivClause Source #
Ord DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering Source # (<) :: DerivStrategy -> DerivStrategy -> Bool Source # (<=) :: DerivStrategy -> DerivStrategy -> Bool Source # (>) :: DerivStrategy -> DerivStrategy -> Bool Source # (>=) :: DerivStrategy -> DerivStrategy -> Bool Source # max :: DerivStrategy -> DerivStrategy -> DerivStrategy Source # min :: DerivStrategy -> DerivStrategy -> DerivStrategy Source #
Ord TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering Source # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead Source # min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead Source #
Ord TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TySynEqn -> TySynEqn -> Ordering Source # (<) :: TySynEqn -> TySynEqn -> Bool Source # (<=) :: TySynEqn -> TySynEqn -> Bool Source # (>) :: TySynEqn -> TySynEqn -> Bool Source # (>=) :: TySynEqn -> TySynEqn -> Bool Source # max :: TySynEqn -> TySynEqn -> TySynEqn Source # min :: TySynEqn -> TySynEqn -> TySynEqn Source #
Ord Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Foreign -> Foreign -> Ordering Source # (<) :: Foreign -> Foreign -> Bool Source # (<=) :: Foreign -> Foreign -> Bool Source # (>) :: Foreign -> Foreign -> Bool Source # (>=) :: Foreign -> Foreign -> Bool Source # max :: Foreign -> Foreign -> Foreign Source # min :: Foreign -> Foreign -> Foreign Source #
Ord Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Callconv -> Callconv -> Ordering Source # (<) :: Callconv -> Callconv -> Bool Source # (<=) :: Callconv -> Callconv -> Bool Source # (>) :: Callconv -> Callconv -> Bool Source # (>=) :: Callconv -> Callconv -> Bool Source # max :: Callconv -> Callconv -> Callconv Source # min :: Callconv -> Callconv -> Callconv Source #
Ord Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Safety -> Safety -> Ordering Source # (<) :: Safety -> Safety -> Bool Source # (<=) :: Safety -> Safety -> Bool Source # (>) :: Safety -> Safety -> Bool Source # (>=) :: Safety -> Safety -> Bool Source # max :: Safety -> Safety -> Safety Source # min :: Safety -> Safety -> Safety Source #
Ord Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Pragma -> Pragma -> Ordering Source # (<) :: Pragma -> Pragma -> Bool Source # (<=) :: Pragma -> Pragma -> Bool Source # (>) :: Pragma -> Pragma -> Bool Source # (>=) :: Pragma -> Pragma -> Bool Source # max :: Pragma -> Pragma -> Pragma Source # min :: Pragma -> Pragma -> Pragma Source #
Ord Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Inline -> Inline -> Ordering Source # (<) :: Inline -> Inline -> Bool Source # (<=) :: Inline -> Inline -> Bool Source # (>) :: Inline -> Inline -> Bool Source # (>=) :: Inline -> Inline -> Bool Source # max :: Inline -> Inline -> Inline Source # min :: Inline -> Inline -> Inline Source #
Ord RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleMatch -> RuleMatch -> Ordering Source # (<) :: RuleMatch -> RuleMatch -> Bool Source # (<=) :: RuleMatch -> RuleMatch -> Bool Source # (>) :: RuleMatch -> RuleMatch -> Bool Source # (>=) :: RuleMatch -> RuleMatch -> Bool Source # max :: RuleMatch -> RuleMatch -> RuleMatch Source # min :: RuleMatch -> RuleMatch -> RuleMatch Source #
Ord Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Phases -> Phases -> Ordering Source # (<) :: Phases -> Phases -> Bool Source # (<=) :: Phases -> Phases -> Bool Source # (>) :: Phases -> Phases -> Bool Source # (>=) :: Phases -> Phases -> Bool Source # max :: Phases -> Phases -> Phases Source # min :: Phases -> Phases -> Phases Source #
Ord RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleBndr -> RuleBndr -> Ordering Source # (<) :: RuleBndr -> RuleBndr -> Bool Source # (<=) :: RuleBndr -> RuleBndr -> Bool Source # (>) :: RuleBndr -> RuleBndr -> Bool Source # (>=) :: RuleBndr -> RuleBndr -> Bool Source # max :: RuleBndr -> RuleBndr -> RuleBndr Source # min :: RuleBndr -> RuleBndr -> RuleBndr Source #
Ord AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnTarget -> AnnTarget -> Ordering Source # (<) :: AnnTarget -> AnnTarget -> Bool Source # (<=) :: AnnTarget -> AnnTarget -> Bool Source # (>) :: AnnTarget -> AnnTarget -> Bool Source # (>=) :: AnnTarget -> AnnTarget -> Bool Source # max :: AnnTarget -> AnnTarget -> AnnTarget Source # min :: AnnTarget -> AnnTarget -> AnnTarget Source #
Ord SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering Source # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source #
Ord SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceStrictness -> SourceStrictness -> Ordering Source # (<) :: SourceStrictness -> SourceStrictness -> Bool Source # (<=) :: SourceStrictness -> SourceStrictness -> Bool Source # (>) :: SourceStrictness -> SourceStrictness -> Bool Source # (>=) :: SourceStrictness -> SourceStrictness -> Bool Source # max :: SourceStrictness -> SourceStrictness -> SourceStrictness Source # min :: SourceStrictness -> SourceStrictness -> SourceStrictness Source #
Ord DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering Source # (<) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source #
Ord Con
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Con -> Con -> Ordering Source # (<) :: Con -> Con -> Bool Source # (<=) :: Con -> Con -> Bool Source # (>) :: Con -> Con -> Bool Source # (>=) :: Con -> Con -> Bool Source # max :: Con -> Con -> Con Source # min :: Con -> Con -> Con Source #
Ord Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Bang -> Bang -> Ordering Source # (<) :: Bang -> Bang -> Bool Source # (<=) :: Bang -> Bang -> Bool Source # (>) :: Bang -> Bang -> Bool Source # (>=) :: Bang -> Bang -> Bool Source # max :: Bang -> Bang -> Bang Source # min :: Bang -> Bang -> Bang Source #
Ord PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynDir -> PatSynDir -> Ordering Source # (<) :: PatSynDir -> PatSynDir -> Bool Source # (<=) :: PatSynDir -> PatSynDir -> Bool Source # (>) :: PatSynDir -> PatSynDir -> Bool Source # (>=) :: PatSynDir -> PatSynDir -> Bool Source # max :: PatSynDir -> PatSynDir -> PatSynDir Source # min :: PatSynDir -> PatSynDir -> PatSynDir Source #
Ord PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynArgs -> PatSynArgs -> Ordering Source # (<) :: PatSynArgs -> PatSynArgs -> Bool Source # (<=) :: PatSynArgs -> PatSynArgs -> Bool Source # (>) :: PatSynArgs -> PatSynArgs -> Bool Source # (>=) :: PatSynArgs -> PatSynArgs -> Bool Source # max :: PatSynArgs -> PatSynArgs -> PatSynArgs Source # min :: PatSynArgs -> PatSynArgs -> PatSynArgs Source #
Ord TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr -> TyVarBndr -> Ordering Source # (<) :: TyVarBndr -> TyVarBndr -> Bool Source # (<=) :: TyVarBndr -> TyVarBndr -> Bool Source # (>) :: TyVarBndr -> TyVarBndr -> Bool Source # (>=) :: TyVarBndr -> TyVarBndr -> Bool Source # max :: TyVarBndr -> TyVarBndr -> TyVarBndr Source # min :: TyVarBndr -> TyVarBndr -> TyVarBndr Source #
Ord FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering Source # (<) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (>) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool Source # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig Source # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig Source #
Ord TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TyLit -> TyLit -> Ordering Source # (<) :: TyLit -> TyLit -> Bool Source # (<=) :: TyLit -> TyLit -> Bool Source # (>) :: TyLit -> TyLit -> Bool Source # (>=) :: TyLit -> TyLit -> Bool Source # max :: TyLit -> TyLit -> TyLit Source # min :: TyLit -> TyLit -> TyLit Source #
Ord Role
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Role -> Role -> Ordering Source # (<) :: Role -> Role -> Bool Source # (<=) :: Role -> Role -> Bool Source # (>) :: Role -> Role -> Bool Source # (>=) :: Role -> Role -> Bool Source # max :: Role -> Role -> Role Source # min :: Role -> Role -> Role Source #
Ord AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnLookup -> AnnLookup -> Ordering Source # (<) :: AnnLookup -> AnnLookup -> Bool Source # (<=) :: AnnLookup -> AnnLookup -> Bool Source # (>) :: AnnLookup -> AnnLookup -> Bool Source # (>=) :: AnnLookup -> AnnLookup -> Bool Source # max :: AnnLookup -> AnnLookup -> AnnLookup Source # min :: AnnLookup -> AnnLookup -> AnnLookup Source #
Ord ShortText
Instance details Defined in Data.Text.Short.Internal Methods compare :: ShortText -> ShortText -> Ordering Source # (<) :: ShortText -> ShortText -> Bool Source # (<=) :: ShortText -> ShortText -> Bool Source # (>) :: ShortText -> ShortText -> Bool Source # (>=) :: ShortText -> ShortText -> Bool Source # max :: ShortText -> ShortText -> ShortText Source # min :: ShortText -> ShortText -> ShortText Source #
Ord LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods compare :: LocalTime -> LocalTime -> Ordering Source # (<) :: LocalTime -> LocalTime -> Bool Source # (<=) :: LocalTime -> LocalTime -> Bool Source # (>) :: LocalTime -> LocalTime -> Bool Source # (>=) :: LocalTime -> LocalTime -> Bool Source # max :: LocalTime -> LocalTime -> LocalTime Source # min :: LocalTime -> LocalTime -> LocalTime Source #
Ord TimeOfDay
Instance details Defined in Data.Time.LocalTime.Internal.TimeOfDay Methods compare :: TimeOfDay -> TimeOfDay -> Ordering Source # (<) :: TimeOfDay -> TimeOfDay -> Bool Source # (<=) :: TimeOfDay -> TimeOfDay -> Bool Source # (>) :: TimeOfDay -> TimeOfDay -> Bool Source # (>=) :: TimeOfDay -> TimeOfDay -> Bool Source # max :: TimeOfDay -> TimeOfDay -> TimeOfDay Source # min :: TimeOfDay -> TimeOfDay -> TimeOfDay Source #
Ord TimeZone
Instance details Defined in Data.Time.LocalTime.Internal.TimeZone Methods compare :: TimeZone -> TimeZone -> Ordering Source # (<) :: TimeZone -> TimeZone -> Bool Source # (<=) :: TimeZone -> TimeZone -> Bool Source # (>) :: TimeZone -> TimeZone -> Bool Source # (>=) :: TimeZone -> TimeZone -> Bool Source # max :: TimeZone -> TimeZone -> TimeZone Source # min :: TimeZone -> TimeZone -> TimeZone Source #
Ord UniversalTime
Instance details Defined in Data.Time.Clock.Internal.UniversalTime Methods compare :: UniversalTime -> UniversalTime -> Ordering Source # (<) :: UniversalTime -> UniversalTime -> Bool Source # (<=) :: UniversalTime -> UniversalTime -> Bool Source # (>) :: UniversalTime -> UniversalTime -> Bool Source # (>=) :: UniversalTime -> UniversalTime -> Bool Source # max :: UniversalTime -> UniversalTime -> UniversalTime Source # min :: UniversalTime -> UniversalTime -> UniversalTime Source #
Ord Day
Instance details Defined in Data.Time.Calendar.Days Methods compare :: Day -> Day -> Ordering Source # (<) :: Day -> Day -> Bool Source # (<=) :: Day -> Day -> Bool Source # (>) :: Day -> Day -> Bool Source # (>=) :: Day -> Day -> Bool Source # max :: Day -> Day -> Day Source # min :: Day -> Day -> Day Source #
Ord UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods compare :: UnpackedUUID -> UnpackedUUID -> Ordering Source # (<) :: UnpackedUUID -> UnpackedUUID -> Bool Source # (<=) :: UnpackedUUID -> UnpackedUUID -> Bool Source # (>) :: UnpackedUUID -> UnpackedUUID -> Bool Source # (>=) :: UnpackedUUID -> UnpackedUUID -> Bool Source # max :: UnpackedUUID -> UnpackedUUID -> UnpackedUUID Source # min :: UnpackedUUID -> UnpackedUUID -> UnpackedUUID Source #
Ord UUID
Instance details Defined in Data.UUID.Types.Internal Methods compare :: UUID -> UUID -> Ordering Source # (<) :: UUID -> UUID -> Bool Source # (<=) :: UUID -> UUID -> Bool Source # (>) :: UUID -> UUID -> Bool Source # (>=) :: UUID -> UUID -> Bool Source # max :: UUID -> UUID -> UUID Source # min :: UUID -> UUID -> UUID Source #
Ord B
Instance details Defined in Data.Text.Short.Internal Methods compare :: B -> B -> Ordering Source # (<) :: B -> B -> Bool Source # (<=) :: B -> B -> Bool Source # (>) :: B -> B -> Bool Source # (>=) :: B -> B -> Bool Source # max :: B -> B -> B Source # min :: B -> B -> B Source #
Ord a => Ord [a]
Instance details Defined in GHC.Classes Methods compare :: [a] -> [a] -> Ordering Source # (<) :: [a] -> [a] -> Bool Source # (<=) :: [a] -> [a] -> Bool Source # (>) :: [a] -> [a] -> Bool Source # (>=) :: [a] -> [a] -> Bool Source # max :: [a] -> [a] -> [a] Source # min :: [a] -> [a] -> [a] Source #
Ord a => Ord ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering Source # (<) :: Maybe a -> Maybe a -> Bool Source # (<=) :: Maybe a -> Maybe a -> Bool Source # (>) :: Maybe a -> Maybe a -> Bool Source # (>=) :: Maybe a -> Maybe a -> Bool Source # max :: Maybe a -> Maybe a -> Maybe a Source # min :: Maybe a -> Maybe a -> Maybe a Source #
Integral a => Ord ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods compare :: Ratio a -> Ratio a -> Ordering Source # (<) :: Ratio a -> Ratio a -> Bool Source # (<=) :: Ratio a -> Ratio a -> Bool Source # (>) :: Ratio a -> Ratio a -> Bool Source # (>=) :: Ratio a -> Ratio a -> Bool Source # max :: Ratio a -> Ratio a -> Ratio a Source # min :: Ratio a -> Ratio a -> Ratio a Source #
Ord ( Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods compare :: Ptr a -> Ptr a -> Ordering Source # (<) :: Ptr a -> Ptr a -> Bool Source # (<=) :: Ptr a -> Ptr a -> Bool Source # (>) :: Ptr a -> Ptr a -> Bool Source # (>=) :: Ptr a -> Ptr a -> Bool Source # max :: Ptr a -> Ptr a -> Ptr a Source # min :: Ptr a -> Ptr a -> Ptr a Source #
Ord ( FunPtr a)
Instance details Defined in GHC.Ptr Methods compare :: FunPtr a -> FunPtr a -> Ordering Source # (<) :: FunPtr a -> FunPtr a -> Bool Source # (<=) :: FunPtr a -> FunPtr a -> Bool Source # (>) :: FunPtr a -> FunPtr a -> Bool Source # (>=) :: FunPtr a -> FunPtr a -> Bool Source # max :: FunPtr a -> FunPtr a -> FunPtr a Source # min :: FunPtr a -> FunPtr a -> FunPtr a Source #
Ord p => Ord ( Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Par1 p -> Par1 p -> Ordering Source # (<) :: Par1 p -> Par1 p -> Bool Source # (<=) :: Par1 p -> Par1 p -> Bool Source # (>) :: Par1 p -> Par1 p -> Bool Source # (>=) :: Par1 p -> Par1 p -> Bool Source # max :: Par1 p -> Par1 p -> Par1 p Source # min :: Par1 p -> Par1 p -> Par1 p Source #
Ord a => Ord ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods compare :: Solo a -> Solo a -> Ordering Source # (<) :: Solo a -> Solo a -> Bool Source # (<=) :: Solo a -> Solo a -> Bool Source # (>) :: Solo a -> Solo a -> Bool Source # (>=) :: Solo a -> Solo a -> Bool Source # max :: Solo a -> Solo a -> Solo a Source # min :: Solo a -> Solo a -> Solo a Source #
Ord v => Ord ( KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods compare :: KeyMap v -> KeyMap v -> Ordering Source # (<) :: KeyMap v -> KeyMap v -> Bool Source # (<=) :: KeyMap v -> KeyMap v -> Bool Source # (>) :: KeyMap v -> KeyMap v -> Bool Source # (>=) :: KeyMap v -> KeyMap v -> Bool Source # max :: KeyMap v -> KeyMap v -> KeyMap v Source # min :: KeyMap v -> KeyMap v -> KeyMap v Source #
Ord ( Async a)
Instance details Defined in Control.Concurrent.Async Methods compare :: Async a -> Async a -> Ordering Source # (<) :: Async a -> Async a -> Bool Source # (<=) :: Async a -> Async a -> Bool Source # (>) :: Async a -> Async a -> Bool Source # (>=) :: Async a -> Async a -> Bool Source # max :: Async a -> Async a -> Async a Source # min :: Async a -> Async a -> Async a Source #
Ord a => Ord ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Min a -> Min a -> Ordering Source # (<) :: Min a -> Min a -> Bool Source # (<=) :: Min a -> Min a -> Bool Source # (>) :: Min a -> Min a -> Bool Source # (>=) :: Min a -> Min a -> Bool Source # max :: Min a -> Min a -> Min a Source # min :: Min a -> Min a -> Min a Source #
Ord a => Ord ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Max a -> Max a -> Ordering Source # (<) :: Max a -> Max a -> Bool Source # (<=) :: Max a -> Max a -> Bool Source # (>) :: Max a -> Max a -> Bool Source # (>=) :: Max a -> Max a -> Bool Source # max :: Max a -> Max a -> Max a Source # min :: Max a -> Max a -> Max a Source #
Ord a => Ord ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: First a -> First a -> Ordering Source # (<) :: First a -> First a -> Bool Source # (<=) :: First a -> First a -> Bool Source # (>) :: First a -> First a -> Bool Source # (>=) :: First a -> First a -> Bool Source # max :: First a -> First a -> First a Source # min :: First a -> First a -> First a Source #
Ord a => Ord ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Last a -> Last a -> Ordering Source # (<) :: Last a -> Last a -> Bool Source # (<=) :: Last a -> Last a -> Bool Source # (>) :: Last a -> Last a -> Bool Source # (>=) :: Last a -> Last a -> Bool Source # max :: Last a -> Last a -> Last a Source # min :: Last a -> Last a -> Last a Source #
Ord m => Ord ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering Source # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source #
Ord a => Ord ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Option a -> Option a -> Ordering Source # (<) :: Option a -> Option a -> Bool Source # (<=) :: Option a -> Option a -> Bool Source # (>) :: Option a -> Option a -> Bool Source # (>=) :: Option a -> Option a -> Bool Source # max :: Option a -> Option a -> Option a Source # min :: Option a -> Option a -> Option a Source #
Ord a => Ord ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods compare :: ZipList a -> ZipList a -> Ordering Source # (<) :: ZipList a -> ZipList a -> Bool Source # (<=) :: ZipList a -> ZipList a -> Bool Source # (>) :: ZipList a -> ZipList a -> Bool Source # (>=) :: ZipList a -> ZipList a -> Bool Source # max :: ZipList a -> ZipList a -> ZipList a Source # min :: ZipList a -> ZipList a -> ZipList a Source #
Ord a => Ord ( Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering Source # (<) :: Identity a -> Identity a -> Bool Source # (<=) :: Identity a -> Identity a -> Bool Source # (>) :: Identity a -> Identity a -> Bool Source # (>=) :: Identity a -> Identity a -> Bool Source # max :: Identity a -> Identity a -> Identity a Source # min :: Identity a -> Identity a -> Identity a Source #
Ord a => Ord ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: First a -> First a -> Ordering Source # (<) :: First a -> First a -> Bool Source # (<=) :: First a -> First a -> Bool Source # (>) :: First a -> First a -> Bool Source # (>=) :: First a -> First a -> Bool Source # max :: First a -> First a -> First a Source # min :: First a -> First a -> First a Source #
Ord a => Ord ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: Last a -> Last a -> Ordering Source # (<) :: Last a -> Last a -> Bool Source # (<=) :: Last a -> Last a -> Bool Source # (>) :: Last a -> Last a -> Bool Source # (>=) :: Last a -> Last a -> Bool Source # max :: Last a -> Last a -> Last a Source # min :: Last a -> Last a -> Last a Source #
Ord a => Ord ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Dual a -> Dual a -> Ordering Source # (<) :: Dual a -> Dual a -> Bool Source # (<=) :: Dual a -> Dual a -> Bool Source # (>) :: Dual a -> Dual a -> Bool Source # (>=) :: Dual a -> Dual a -> Bool Source # max :: Dual a -> Dual a -> Dual a Source # min :: Dual a -> Dual a -> Dual a Source #
Ord a => Ord ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Sum a -> Sum a -> Ordering Source # (<) :: Sum a -> Sum a -> Bool Source # (<=) :: Sum a -> Sum a -> Bool Source # (>) :: Sum a -> Sum a -> Bool Source # (>=) :: Sum a -> Sum a -> Bool Source # max :: Sum a -> Sum a -> Sum a Source # min :: Sum a -> Sum a -> Sum a Source #
Ord a => Ord ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Product a -> Product a -> Ordering Source # (<) :: Product a -> Product a -> Bool Source # (<=) :: Product a -> Product a -> Bool Source # (>) :: Product a -> Product a -> Bool Source # (>=) :: Product a -> Product a -> Bool Source # max :: Product a -> Product a -> Product a Source # min :: Product a -> Product a -> Product a Source #
Ord a => Ord ( Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods compare :: Down a -> Down a -> Ordering Source # (<) :: Down a -> Down a -> Bool Source # (<=) :: Down a -> Down a -> Bool Source # (>) :: Down a -> Down a -> Bool Source # (>=) :: Down a -> Down a -> Bool Source # max :: Down a -> Down a -> Down a Source # min :: Down a -> Down a -> Down a Source #
Ord a => Ord ( NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering Source # (<) :: NonEmpty a -> NonEmpty a -> Bool Source # (<=) :: NonEmpty a -> NonEmpty a -> Bool Source # (>) :: NonEmpty a -> NonEmpty a -> Bool Source # (>=) :: NonEmpty a -> NonEmpty a -> Bool Source # max :: NonEmpty a -> NonEmpty a -> NonEmpty a Source # min :: NonEmpty a -> NonEmpty a -> NonEmpty a Source #
Ord a => Ord ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods compare :: IntMap a -> IntMap a -> Ordering Source # (<) :: IntMap a -> IntMap a -> Bool Source # (<=) :: IntMap a -> IntMap a -> Bool Source # (>) :: IntMap a -> IntMap a -> Bool Source # (>=) :: IntMap a -> IntMap a -> Bool Source # max :: IntMap a -> IntMap a -> IntMap a Source # min :: IntMap a -> IntMap a -> IntMap a Source #
Ord a => Ord ( Tree a)	Since: containers-0.6.5
Instance details Defined in Data.Tree Methods compare :: Tree a -> Tree a -> Ordering Source # (<) :: Tree a -> Tree a -> Bool Source # (<=) :: Tree a -> Tree a -> Bool Source # (>) :: Tree a -> Tree a -> Bool Source # (>=) :: Tree a -> Tree a -> Bool Source # max :: Tree a -> Tree a -> Tree a Source # min :: Tree a -> Tree a -> Tree a Source #
Ord a => Ord ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods compare :: Seq a -> Seq a -> Ordering Source # (<) :: Seq a -> Seq a -> Bool Source # (<=) :: Seq a -> Seq a -> Bool Source # (>) :: Seq a -> Seq a -> Bool Source # (>=) :: Seq a -> Seq a -> Bool Source # max :: Seq a -> Seq a -> Seq a Source # min :: Seq a -> Seq a -> Seq a Source #
Ord a => Ord ( ViewL a)
Instance details Defined in Data.Sequence.Internal Methods compare :: ViewL a -> ViewL a -> Ordering Source # (<) :: ViewL a -> ViewL a -> Bool Source # (<=) :: ViewL a -> ViewL a -> Bool Source # (>) :: ViewL a -> ViewL a -> Bool Source # (>=) :: ViewL a -> ViewL a -> Bool Source # max :: ViewL a -> ViewL a -> ViewL a Source # min :: ViewL a -> ViewL a -> ViewL a Source #
Ord a => Ord ( ViewR a)
Instance details Defined in Data.Sequence.Internal Methods compare :: ViewR a -> ViewR a -> Ordering Source # (<) :: ViewR a -> ViewR a -> Bool Source # (<=) :: ViewR a -> ViewR a -> Bool Source # (>) :: ViewR a -> ViewR a -> Bool Source # (>=) :: ViewR a -> ViewR a -> Bool Source # max :: ViewR a -> ViewR a -> ViewR a Source # min :: ViewR a -> ViewR a -> ViewR a Source #
Ord a => Ord ( Set a)
Instance details Defined in Data.Set.Internal Methods compare :: Set a -> Set a -> Ordering Source # (<) :: Set a -> Set a -> Bool Source # (<=) :: Set a -> Set a -> Bool Source # (>) :: Set a -> Set a -> Bool Source # (>=) :: Set a -> Set a -> Bool Source # max :: Set a -> Set a -> Set a Source # min :: Set a -> Set a -> Set a Source #
Ord1 f => Ord ( Fix f)
Instance details Defined in Data.Fix Methods compare :: Fix f -> Fix f -> Ordering Source # (<) :: Fix f -> Fix f -> Bool Source # (<=) :: Fix f -> Fix f -> Bool Source # (>) :: Fix f -> Fix f -> Bool Source # (>=) :: Fix f -> Fix f -> Bool Source # max :: Fix f -> Fix f -> Fix f Source # min :: Fix f -> Fix f -> Fix f Source #
( Functor f, Ord1 f) => Ord ( Mu f)
Instance details Defined in Data.Fix Methods compare :: Mu f -> Mu f -> Ordering Source # (<) :: Mu f -> Mu f -> Bool Source # (<=) :: Mu f -> Mu f -> Bool Source # (>) :: Mu f -> Mu f -> Bool Source # (>=) :: Mu f -> Mu f -> Bool Source # max :: Mu f -> Mu f -> Mu f Source # min :: Mu f -> Mu f -> Mu f Source #
( Functor f, Ord1 f) => Ord ( Nu f)
Instance details Defined in Data.Fix Methods compare :: Nu f -> Nu f -> Ordering Source # (<) :: Nu f -> Nu f -> Bool Source # (<=) :: Nu f -> Nu f -> Bool Source # (>) :: Nu f -> Nu f -> Bool Source # (>=) :: Nu f -> Nu f -> Bool Source # max :: Nu f -> Nu f -> Nu f Source # min :: Nu f -> Nu f -> Nu f Source #
Ord a => Ord ( DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods compare :: DNonEmpty a -> DNonEmpty a -> Ordering Source # (<) :: DNonEmpty a -> DNonEmpty a -> Bool Source # (<=) :: DNonEmpty a -> DNonEmpty a -> Bool Source # (>) :: DNonEmpty a -> DNonEmpty a -> Bool Source # (>=) :: DNonEmpty a -> DNonEmpty a -> Bool Source # max :: DNonEmpty a -> DNonEmpty a -> DNonEmpty a Source # min :: DNonEmpty a -> DNonEmpty a -> DNonEmpty a Source #
Ord a => Ord ( DList a)
Instance details Defined in Data.DList.Internal Methods compare :: DList a -> DList a -> Ordering Source # (<) :: DList a -> DList a -> Bool Source # (<=) :: DList a -> DList a -> Bool Source # (>) :: DList a -> DList a -> Bool Source # (>=) :: DList a -> DList a -> Bool Source # max :: DList a -> DList a -> DList a Source # min :: DList a -> DList a -> DList a Source #
Ord a => Ord ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods compare :: Hex a -> Hex a -> Ordering Source # (<) :: Hex a -> Hex a -> Bool Source # (<=) :: Hex a -> Hex a -> Bool Source # (>) :: Hex a -> Hex a -> Bool Source # (>=) :: Hex a -> Hex a -> Bool Source # max :: Hex a -> Hex a -> Hex a Source # min :: Hex a -> Hex a -> Hex a Source #
Ord a => Ord ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods compare :: Shown a -> Shown a -> Ordering Source # (<) :: Shown a -> Shown a -> Bool Source # (<=) :: Shown a -> Shown a -> Bool Source # (>) :: Shown a -> Shown a -> Bool Source # (>=) :: Shown a -> Shown a -> Bool Source # max :: Shown a -> Shown a -> Shown a Source # min :: Shown a -> Shown a -> Shown a Source #
Ord a => Ord ( Hashed a)
Instance details Defined in Data.Hashable.Class Methods compare :: Hashed a -> Hashed a -> Ordering Source # (<) :: Hashed a -> Hashed a -> Bool Source # (<=) :: Hashed a -> Hashed a -> Bool Source # (>) :: Hashed a -> Hashed a -> Bool Source # (>=) :: Hashed a -> Hashed a -> Bool Source # max :: Hashed a -> Hashed a -> Hashed a Source # min :: Hashed a -> Hashed a -> Hashed a Source #
( Ord a, Prim a) => Ord ( PrimArray a)	Lexicographic ordering. Subject to change between major versions. Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods compare :: PrimArray a -> PrimArray a -> Ordering Source # (<) :: PrimArray a -> PrimArray a -> Bool Source # (<=) :: PrimArray a -> PrimArray a -> Bool Source # (>) :: PrimArray a -> PrimArray a -> Bool Source # (>=) :: PrimArray a -> PrimArray a -> Bool Source # max :: PrimArray a -> PrimArray a -> PrimArray a Source # min :: PrimArray a -> PrimArray a -> PrimArray a Source #
Ord a => Ord ( SmallArray a)	Lexicographic ordering. Subject to change between major versions.
Instance details Defined in Data.Primitive.SmallArray Methods compare :: SmallArray a -> SmallArray a -> Ordering Source # (<) :: SmallArray a -> SmallArray a -> Bool Source # (<=) :: SmallArray a -> SmallArray a -> Bool Source # (>) :: SmallArray a -> SmallArray a -> Bool Source # (>=) :: SmallArray a -> SmallArray a -> Bool Source # max :: SmallArray a -> SmallArray a -> SmallArray a Source # min :: SmallArray a -> SmallArray a -> SmallArray a Source #
Ord a => Ord ( Array a)	Lexicographic ordering. Subject to change between major versions.
Instance details Defined in Data.Primitive.Array Methods compare :: Array a -> Array a -> Ordering Source # (<) :: Array a -> Array a -> Bool Source # (<=) :: Array a -> Array a -> Bool Source # (>) :: Array a -> Array a -> Bool Source # (>=) :: Array a -> Array a -> Bool Source # max :: Array a -> Array a -> Array a Source # min :: Array a -> Array a -> Array a Source #
Ord g => Ord ( AtomicGen g)
Instance details Defined in System.Random.Stateful Methods compare :: AtomicGen g -> AtomicGen g -> Ordering Source # (<) :: AtomicGen g -> AtomicGen g -> Bool Source # (<=) :: AtomicGen g -> AtomicGen g -> Bool Source # (>) :: AtomicGen g -> AtomicGen g -> Bool Source # (>=) :: AtomicGen g -> AtomicGen g -> Bool Source # max :: AtomicGen g -> AtomicGen g -> AtomicGen g Source # min :: AtomicGen g -> AtomicGen g -> AtomicGen g Source #
Ord g => Ord ( IOGen g)
Instance details Defined in System.Random.Stateful Methods compare :: IOGen g -> IOGen g -> Ordering Source # (<) :: IOGen g -> IOGen g -> Bool Source # (<=) :: IOGen g -> IOGen g -> Bool Source # (>) :: IOGen g -> IOGen g -> Bool Source # (>=) :: IOGen g -> IOGen g -> Bool Source # max :: IOGen g -> IOGen g -> IOGen g Source # min :: IOGen g -> IOGen g -> IOGen g Source #
Ord g => Ord ( STGen g)
Instance details Defined in System.Random.Stateful Methods compare :: STGen g -> STGen g -> Ordering Source # (<) :: STGen g -> STGen g -> Bool Source # (<=) :: STGen g -> STGen g -> Bool Source # (>) :: STGen g -> STGen g -> Bool Source # (>=) :: STGen g -> STGen g -> Bool Source # max :: STGen g -> STGen g -> STGen g Source # min :: STGen g -> STGen g -> STGen g Source #
Ord g => Ord ( TGen g)
Instance details Defined in System.Random.Stateful Methods compare :: TGen g -> TGen g -> Ordering Source # (<) :: TGen g -> TGen g -> Bool Source # (<=) :: TGen g -> TGen g -> Bool Source # (>) :: TGen g -> TGen g -> Bool Source # (>=) :: TGen g -> TGen g -> Bool Source # max :: TGen g -> TGen g -> TGen g Source # min :: TGen g -> TGen g -> TGen g Source #
Ord g => Ord ( StateGen g)
Instance details Defined in System.Random.Internal Methods compare :: StateGen g -> StateGen g -> Ordering Source # (<) :: StateGen g -> StateGen g -> Bool Source # (<=) :: StateGen g -> StateGen g -> Bool Source # (>) :: StateGen g -> StateGen g -> Bool Source # (>=) :: StateGen g -> StateGen g -> Bool Source # max :: StateGen g -> StateGen g -> StateGen g Source # min :: StateGen g -> StateGen g -> StateGen g Source #
Ord a => Ord ( Maybe a)
Instance details Defined in Data.Strict.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering Source # (<) :: Maybe a -> Maybe a -> Bool Source # (<=) :: Maybe a -> Maybe a -> Bool Source # (>) :: Maybe a -> Maybe a -> Bool Source # (>=) :: Maybe a -> Maybe a -> Bool Source # max :: Maybe a -> Maybe a -> Maybe a Source # min :: Maybe a -> Maybe a -> Maybe a Source #
Ord a => Ord ( HashSet a)
Instance details Defined in Data.HashSet.Internal Methods compare :: HashSet a -> HashSet a -> Ordering Source # (<) :: HashSet a -> HashSet a -> Bool Source # (<=) :: HashSet a -> HashSet a -> Bool Source # (>) :: HashSet a -> HashSet a -> Bool Source # (>=) :: HashSet a -> HashSet a -> Bool Source # max :: HashSet a -> HashSet a -> HashSet a Source # min :: HashSet a -> HashSet a -> HashSet a Source #
( Storable a, Ord a) => Ord ( Vector a)
Instance details Defined in Data.Vector.Storable Methods compare :: Vector a -> Vector a -> Ordering Source # (<) :: Vector a -> Vector a -> Bool Source # (<=) :: Vector a -> Vector a -> Bool Source # (>) :: Vector a -> Vector a -> Bool Source # (>=) :: Vector a -> Vector a -> Bool Source # max :: Vector a -> Vector a -> Vector a Source # min :: Vector a -> Vector a -> Vector a Source #
( Prim a, Ord a) => Ord ( Vector a)
Instance details Defined in Data.Vector.Primitive Methods compare :: Vector a -> Vector a -> Ordering Source # (<) :: Vector a -> Vector a -> Bool Source # (<=) :: Vector a -> Vector a -> Bool Source # (>) :: Vector a -> Vector a -> Bool Source # (>=) :: Vector a -> Vector a -> Bool Source # max :: Vector a -> Vector a -> Vector a Source # min :: Vector a -> Vector a -> Vector a Source #
Ord a => Ord ( Vector a)
Instance details Defined in Data.Vector Methods compare :: Vector a -> Vector a -> Ordering Source # (<) :: Vector a -> Vector a -> Bool Source # (<=) :: Vector a -> Vector a -> Bool Source # (>) :: Vector a -> Vector a -> Bool Source # (>=) :: Vector a -> Vector a -> Bool Source # max :: Vector a -> Vector a -> Vector a Source # min :: Vector a -> Vector a -> Vector a Source #
( Ord a, Ord b) => Ord ( Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering Source # (<) :: Either a b -> Either a b -> Bool Source # (<=) :: Either a b -> Either a b -> Bool Source # (>) :: Either a b -> Either a b -> Bool Source # (>=) :: Either a b -> Either a b -> Bool Source # max :: Either a b -> Either a b -> Either a b Source # min :: Either a b -> Either a b -> Either a b Source #
Ord ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: V1 p -> V1 p -> Ordering Source # (<) :: V1 p -> V1 p -> Bool Source # (<=) :: V1 p -> V1 p -> Bool Source # (>) :: V1 p -> V1 p -> Bool Source # (>=) :: V1 p -> V1 p -> Bool Source # max :: V1 p -> V1 p -> V1 p Source # min :: V1 p -> V1 p -> V1 p Source #
Ord ( U1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: U1 p -> U1 p -> Ordering Source # (<) :: U1 p -> U1 p -> Bool Source # (<=) :: U1 p -> U1 p -> Bool Source # (>) :: U1 p -> U1 p -> Bool Source # (>=) :: U1 p -> U1 p -> Bool Source # max :: U1 p -> U1 p -> U1 p Source # min :: U1 p -> U1 p -> U1 p Source #
Ord ( TypeRep a)	Since: base-4.4.0.0
Instance details Defined in Data.Typeable.Internal Methods compare :: TypeRep a -> TypeRep a -> Ordering Source # (<) :: TypeRep a -> TypeRep a -> Bool Source # (<=) :: TypeRep a -> TypeRep a -> Bool Source # (>) :: TypeRep a -> TypeRep a -> Bool Source # (>=) :: TypeRep a -> TypeRep a -> Bool Source # max :: TypeRep a -> TypeRep a -> TypeRep a Source # min :: TypeRep a -> TypeRep a -> TypeRep a Source #
( Ord a, Ord b) => Ord (a, b)
Instance details Defined in GHC.Classes Methods compare :: (a, b) -> (a, b) -> Ordering Source # (<) :: (a, b) -> (a, b) -> Bool Source # (<=) :: (a, b) -> (a, b) -> Bool Source # (>) :: (a, b) -> (a, b) -> Bool Source # (>=) :: (a, b) -> (a, b) -> Bool Source # max :: (a, b) -> (a, b) -> (a, b) Source # min :: (a, b) -> (a, b) -> (a, b) Source #
( Ord k, Ord v) => Ord ( Map k v)
Instance details Defined in Data.Map.Internal Methods compare :: Map k v -> Map k v -> Ordering Source # (<) :: Map k v -> Map k v -> Bool Source # (<=) :: Map k v -> Map k v -> Bool Source # (>) :: Map k v -> Map k v -> Bool Source # (>=) :: Map k v -> Map k v -> Bool Source # max :: Map k v -> Map k v -> Map k v Source # min :: Map k v -> Map k v -> Map k v Source #
( Ord k, Ord v) => Ord ( HashMap k v)	The ordering is total and consistent with the `Eq` instance. However, nothing else about the ordering is specified, and it may change from version to version of either this package or of hashable.
Instance details Defined in Data.HashMap.Internal Methods compare :: HashMap k v -> HashMap k v -> Ordering Source # (<) :: HashMap k v -> HashMap k v -> Bool Source # (<=) :: HashMap k v -> HashMap k v -> Bool Source # (>) :: HashMap k v -> HashMap k v -> Bool Source # (>=) :: HashMap k v -> HashMap k v -> Bool Source # max :: HashMap k v -> HashMap k v -> HashMap k v Source # min :: HashMap k v -> HashMap k v -> HashMap k v Source #
( Ix ix, Ord e, IArray UArray e) => Ord ( UArray ix e)
Instance details Defined in Data.Array.Base Methods compare :: UArray ix e -> UArray ix e -> Ordering Source # (<) :: UArray ix e -> UArray ix e -> Bool Source # (<=) :: UArray ix e -> UArray ix e -> Bool Source # (>) :: UArray ix e -> UArray ix e -> Bool Source # (>=) :: UArray ix e -> UArray ix e -> Bool Source # max :: UArray ix e -> UArray ix e -> UArray ix e Source # min :: UArray ix e -> UArray ix e -> UArray ix e Source #
( Ix i, Ord e) => Ord ( Array i e)	Since: base-2.1
Instance details Defined in GHC.Arr Methods compare :: Array i e -> Array i e -> Ordering Source # (<) :: Array i e -> Array i e -> Bool Source # (<=) :: Array i e -> Array i e -> Bool Source # (>) :: Array i e -> Array i e -> Bool Source # (>=) :: Array i e -> Array i e -> Bool Source # max :: Array i e -> Array i e -> Array i e Source # min :: Array i e -> Array i e -> Array i e Source #
Ord ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods compare :: Fixed a -> Fixed a -> Ordering Source # (<) :: Fixed a -> Fixed a -> Bool Source # (<=) :: Fixed a -> Fixed a -> Bool Source # (>) :: Fixed a -> Fixed a -> Bool Source # (>=) :: Fixed a -> Fixed a -> Bool Source # max :: Fixed a -> Fixed a -> Fixed a Source # min :: Fixed a -> Fixed a -> Fixed a Source #
Ord a => Ord ( Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Arg a b -> Arg a b -> Ordering Source # (<) :: Arg a b -> Arg a b -> Bool Source # (<=) :: Arg a b -> Arg a b -> Bool Source # (>) :: Arg a b -> Arg a b -> Bool Source # (>=) :: Arg a b -> Arg a b -> Bool Source # max :: Arg a b -> Arg a b -> Arg a b Source # min :: Arg a b -> Arg a b -> Arg a b Source #
Ord ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods compare :: Proxy s -> Proxy s -> Ordering Source # (<) :: Proxy s -> Proxy s -> Bool Source # (<=) :: Proxy s -> Proxy s -> Bool Source # (>) :: Proxy s -> Proxy s -> Bool Source # (>=) :: Proxy s -> Proxy s -> Bool Source # max :: Proxy s -> Proxy s -> Proxy s Source # min :: Proxy s -> Proxy s -> Proxy s Source #
( Ord1 m, Ord a) => Ord ( ListT m a)
Instance details Defined in Control.Monad.Trans.List Methods compare :: ListT m a -> ListT m a -> Ordering Source # (<) :: ListT m a -> ListT m a -> Bool Source # (<=) :: ListT m a -> ListT m a -> Bool Source # (>) :: ListT m a -> ListT m a -> Bool Source # (>=) :: ListT m a -> ListT m a -> Bool Source # max :: ListT m a -> ListT m a -> ListT m a Source # min :: ListT m a -> ListT m a -> ListT m a Source #
( Ord a, Ord b) => Ord ( These a b)
Instance details Defined in Data.These Methods compare :: These a b -> These a b -> Ordering Source # (<) :: These a b -> These a b -> Bool Source # (<=) :: These a b -> These a b -> Bool Source # (>) :: These a b -> These a b -> Bool Source # (>=) :: These a b -> These a b -> Bool Source # max :: These a b -> These a b -> These a b Source # min :: These a b -> These a b -> These a b Source #
( Ord a, Ord b) => Ord ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods compare :: Pair a b -> Pair a b -> Ordering Source # (<) :: Pair a b -> Pair a b -> Bool Source # (<=) :: Pair a b -> Pair a b -> Bool Source # (>) :: Pair a b -> Pair a b -> Bool Source # (>=) :: Pair a b -> Pair a b -> Bool Source # max :: Pair a b -> Pair a b -> Pair a b Source # min :: Pair a b -> Pair a b -> Pair a b Source #
( Ord a, Ord b) => Ord ( These a b)
Instance details Defined in Data.Strict.These Methods compare :: These a b -> These a b -> Ordering Source # (<) :: These a b -> These a b -> Bool Source # (<=) :: These a b -> These a b -> Bool Source # (>) :: These a b -> These a b -> Bool Source # (>=) :: These a b -> These a b -> Bool Source # max :: These a b -> These a b -> These a b Source # min :: These a b -> These a b -> These a b Source #
( Ord a, Ord b) => Ord ( Either a b)
Instance details Defined in Data.Strict.Either Methods compare :: Either a b -> Either a b -> Ordering Source # (<) :: Either a b -> Either a b -> Bool Source # (<=) :: Either a b -> Either a b -> Bool Source # (>) :: Either a b -> Either a b -> Bool Source # (>=) :: Either a b -> Either a b -> Bool Source # max :: Either a b -> Either a b -> Either a b Source # min :: Either a b -> Either a b -> Either a b Source #
( Ord1 m, Ord a) => Ord ( MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods compare :: MaybeT m a -> MaybeT m a -> Ordering Source # (<) :: MaybeT m a -> MaybeT m a -> Bool Source # (<=) :: MaybeT m a -> MaybeT m a -> Bool Source # (>) :: MaybeT m a -> MaybeT m a -> Bool Source # (>=) :: MaybeT m a -> MaybeT m a -> Bool Source # max :: MaybeT m a -> MaybeT m a -> MaybeT m a Source # min :: MaybeT m a -> MaybeT m a -> MaybeT m a Source #
Ord (f p) => Ord ( Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Rec1 f p -> Rec1 f p -> Ordering Source # (<) :: Rec1 f p -> Rec1 f p -> Bool Source # (<=) :: Rec1 f p -> Rec1 f p -> Bool Source # (>) :: Rec1 f p -> Rec1 f p -> Bool Source # (>=) :: Rec1 f p -> Rec1 f p -> Bool Source # max :: Rec1 f p -> Rec1 f p -> Rec1 f p Source # min :: Rec1 f p -> Rec1 f p -> Rec1 f p Source #
Ord ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Ordering Source # (<) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (<=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # max :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source # min :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source #
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 Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source # max :: URec Char p -> URec Char p -> URec Char p Source # min :: URec Char p -> URec Char p -> URec Char p Source #
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 Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source #
Ord ( URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source #
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 Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source # max :: URec Int p -> URec Int p -> URec Int p Source # min :: URec Int p -> URec Int p -> URec Int p Source #
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 Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source # max :: URec Word p -> URec Word p -> URec Word p Source # min :: URec Word p -> URec Word p -> URec Word p Source #
( Ord a, Ord b, Ord c) => Ord (a, b, c)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c) -> (a, b, c) -> Ordering Source # (<) :: (a, b, c) -> (a, b, c) -> Bool Source # (<=) :: (a, b, c) -> (a, b, c) -> Bool Source # (>) :: (a, b, c) -> (a, b, c) -> Bool Source # (>=) :: (a, b, c) -> (a, b, c) -> Bool Source # max :: (a, b, c) -> (a, b, c) -> (a, b, c) Source # min :: (a, b, c) -> (a, b, c) -> (a, b, c) Source #
Ord a => Ord ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering Source # (<) :: Const a b -> Const a b -> Bool Source # (<=) :: Const a b -> Const a b -> Bool Source # (>) :: Const a b -> Const a b -> Bool Source # (>=) :: Const a b -> Const a b -> Bool Source # max :: Const a b -> Const a b -> Const a b Source # min :: Const a b -> Const a b -> Const a b Source #
Ord (f a) => Ord ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods compare :: Ap f a -> Ap f a -> Ordering Source # (<) :: Ap f a -> Ap f a -> Bool Source # (<=) :: Ap f a -> Ap f a -> Bool Source # (>) :: Ap f a -> Ap f a -> Bool Source # (>=) :: Ap f a -> Ap f a -> Bool Source # max :: Ap f a -> Ap f a -> Ap f a Source # min :: Ap f a -> Ap f a -> Ap f a Source #
Ord (f a) => Ord ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods compare :: Alt f a -> Alt f a -> Ordering Source # (<) :: Alt f a -> Alt f a -> Bool Source # (<=) :: Alt f a -> Alt f a -> Bool Source # (>) :: Alt f a -> Alt f a -> Bool Source # (>=) :: Alt f a -> Alt f a -> Bool Source # max :: Alt f a -> Alt f a -> Alt f a Source # min :: Alt f a -> Alt f a -> Alt f a Source #
Ord ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods compare :: Coercion a b -> Coercion a b -> Ordering Source # (<) :: Coercion a b -> Coercion a b -> Bool Source # (<=) :: Coercion a b -> Coercion a b -> Bool Source # (>) :: Coercion a b -> Coercion a b -> Bool Source # (>=) :: Coercion a b -> Coercion a b -> Bool Source # max :: Coercion a b -> Coercion a b -> Coercion a b Source # min :: Coercion a b -> Coercion a b -> Coercion a b Source #
Ord (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods compare :: (a :~: b) -> (a :~: b) -> Ordering Source # (<) :: (a :~: b) -> (a :~: b) -> Bool Source # (<=) :: (a :~: b) -> (a :~: b) -> Bool Source # (>) :: (a :~: b) -> (a :~: b) -> Bool Source # (>=) :: (a :~: b) -> (a :~: b) -> Bool Source # max :: (a :~: b) -> (a :~: b) -> a :~: b Source # min :: (a :~: b) -> (a :~: b) -> a :~: b Source #
( Ord1 f, Ord a) => Ord ( IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering Source # (<) :: IdentityT f a -> IdentityT f a -> Bool Source # (<=) :: IdentityT f a -> IdentityT f a -> Bool Source # (>) :: IdentityT f a -> IdentityT f a -> Bool Source # (>=) :: IdentityT f a -> IdentityT f a -> Bool Source # max :: IdentityT f a -> IdentityT f a -> IdentityT f a Source # min :: IdentityT f a -> IdentityT f a -> IdentityT f a Source #
( Ord e, Ord1 m, Ord a) => Ord ( ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods compare :: ErrorT e m a -> ErrorT e m a -> Ordering Source # (<) :: ErrorT e m a -> ErrorT e m a -> Bool Source # (<=) :: ErrorT e m a -> ErrorT e m a -> Bool Source # (>) :: ErrorT e m a -> ErrorT e m a -> Bool Source # (>=) :: ErrorT e m a -> ErrorT e m a -> Bool Source # max :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source # min :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source #
( Ord e, Ord1 m, Ord a) => Ord ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering Source # (<) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (>) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool Source # max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source # min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source #
( Ord w, Ord1 m, Ord a) => Ord ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods compare :: WriterT w m a -> WriterT w m a -> Ordering Source # (<) :: WriterT w m a -> WriterT w m a -> Bool Source # (<=) :: WriterT w m a -> WriterT w m a -> Bool Source # (>) :: WriterT w m a -> WriterT w m a -> Bool Source # (>=) :: WriterT w m a -> WriterT w m a -> Bool Source # max :: WriterT w m a -> WriterT w m a -> WriterT w m a Source # min :: WriterT w m a -> WriterT w m a -> WriterT w m a Source #
( Ord w, Ord1 m, Ord a) => Ord ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods compare :: WriterT w m a -> WriterT w m a -> Ordering Source # (<) :: WriterT w m a -> WriterT w m a -> Bool Source # (<=) :: WriterT w m a -> WriterT w m a -> Bool Source # (>) :: WriterT w m a -> WriterT w m a -> Bool Source # (>=) :: WriterT w m a -> WriterT w m a -> Bool Source # max :: WriterT w m a -> WriterT w m a -> WriterT w m a Source # min :: WriterT w m a -> WriterT w m a -> WriterT w m a Source #
Ord b => Ord ( Tagged s b)
Instance details Defined in Data.Tagged Methods compare :: Tagged s b -> Tagged s b -> Ordering Source # (<) :: Tagged s b -> Tagged s b -> Bool Source # (<=) :: Tagged s b -> Tagged s b -> Bool Source # (>) :: Tagged s b -> Tagged s b -> Bool Source # (>=) :: Tagged s b -> Tagged s b -> Bool Source # max :: Tagged s b -> Tagged s b -> Tagged s b Source # min :: Tagged s b -> Tagged s b -> Tagged s b Source #
( Ord1 f, Ord1 g, Ord a) => Ord ( These1 f g a)
Instance details Defined in Data.Functor.These Methods compare :: These1 f g a -> These1 f g a -> Ordering Source # (<) :: These1 f g a -> These1 f g a -> Bool Source # (<=) :: These1 f g a -> These1 f g a -> Bool Source # (>) :: These1 f g a -> These1 f g a -> Bool Source # (>=) :: These1 f g a -> These1 f g a -> Bool Source # max :: These1 f g a -> These1 f g a -> These1 f g a Source # min :: These1 f g a -> These1 f g a -> These1 f g a Source #
Ord c => Ord ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: K1 i c p -> K1 i c p -> Ordering Source # (<) :: K1 i c p -> K1 i c p -> Bool Source # (<=) :: K1 i c p -> K1 i c p -> Bool Source # (>) :: K1 i c p -> K1 i c p -> Bool Source # (>=) :: K1 i c p -> K1 i c p -> Bool Source # max :: K1 i c p -> K1 i c p -> K1 i c p Source # min :: K1 i c p -> K1 i c p -> K1 i c p Source #
( Ord (f p), Ord (g p)) => Ord ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :+: g) p -> (f :+: g) p -> Ordering Source # (<) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (<=) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>=) :: (f :+: g) p -> (f :+: g) p -> Bool Source # max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source # min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source #
( Ord (f p), Ord (g p)) => Ord ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :: g) p -> (f :: g) p -> Ordering Source # (<) :: (f :: g) p -> (f :: g) p -> Bool Source # (<=) :: (f :: g) p -> (f :: g) p -> Bool Source # (>) :: (f :: g) p -> (f :: g) p -> Bool Source # (>=) :: (f :: g) p -> (f :: g) p -> Bool Source # max :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # min :: (f :: g) p -> (f :: g) p -> (f :: g) p Source #
( Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering Source # (<) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # (<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # (>) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # (>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source # min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source #
( Ord1 f, Ord1 g, Ord a) => Ord ( Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering Source # (<) :: Product f g a -> Product f g a -> Bool Source # (<=) :: Product f g a -> Product f g a -> Bool Source # (>) :: Product f g a -> Product f g a -> Bool Source # (>=) :: Product f g a -> Product f g a -> Bool Source # max :: Product f g a -> Product f g a -> Product f g a Source # min :: Product f g a -> Product f g a -> Product f g a Source #
( Ord1 f, Ord1 g, Ord a) => Ord ( Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods compare :: Sum f g a -> Sum f g a -> Ordering Source # (<) :: Sum f g a -> Sum f g a -> Bool Source # (<=) :: Sum f g a -> Sum f g a -> Bool Source # (>) :: Sum f g a -> Sum f g a -> Bool Source # (>=) :: Sum f g a -> Sum f g a -> Bool Source # max :: Sum f g a -> Sum f g a -> Sum f g a Source # min :: Sum f g a -> Sum f g a -> Sum f g a Source #
Ord (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods compare :: (a :~~: b) -> (a :~~: b) -> Ordering Source # (<) :: (a :~~: b) -> (a :~~: b) -> Bool Source # (<=) :: (a :~~: b) -> (a :~~: b) -> Bool Source # (>) :: (a :~~: b) -> (a :~~: b) -> Bool Source # (>=) :: (a :~~: b) -> (a :~~: b) -> Bool Source # max :: (a :~~: b) -> (a :~~: b) -> a :~~: b Source # min :: (a :~~: b) -> (a :~~: b) -> a :~~: b Source #
Ord (f p) => Ord ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: M1 i c f p -> M1 i c f p -> Ordering Source # (<) :: M1 i c f p -> M1 i c f p -> Bool Source # (<=) :: M1 i c f p -> M1 i c f p -> Bool Source # (>) :: M1 i c f p -> M1 i c f p -> Bool Source # (>=) :: M1 i c f p -> M1 i c f p -> Bool Source # max :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # min :: M1 i c f p -> M1 i c f p -> M1 i c f p Source #
Ord (f (g p)) => Ord ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :.: g) p -> (f :.: g) p -> Ordering Source # (<) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (<=) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>=) :: (f :.: g) p -> (f :.: g) p -> Bool Source # max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source #
( Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering Source # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source #
( Ord1 f, Ord1 g, Ord a) => Ord ( Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering Source # (<) :: Compose f g a -> Compose f g a -> Bool Source # (<=) :: Compose f g a -> Compose f g a -> Bool Source # (>) :: Compose f g a -> Compose f g a -> Bool Source # (>=) :: Compose f g a -> Compose f g a -> Bool Source # max :: Compose f g a -> Compose f g a -> Compose f g a Source # min :: Compose f g a -> Compose f g a -> Compose f g a Source #
Ord (p b a) => Ord ( Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods compare :: Flip p a b -> Flip p a b -> Ordering Source # (<) :: Flip p a b -> Flip p a b -> Bool Source # (<=) :: Flip p a b -> Flip p a b -> Bool Source # (>) :: Flip p a b -> Flip p a b -> Bool Source # (>=) :: Flip p a b -> Flip p a b -> Bool Source # max :: Flip p a b -> Flip p a b -> Flip p a b Source # min :: Flip p a b -> Flip p a b -> Flip p a b Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering Source # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) Source # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) Source #
( Ord (p a b), Ord (q a b)) => Ord ( Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods compare :: Sum p q a b -> Sum p q a b -> Ordering Source # (<) :: Sum p q a b -> Sum p q a b -> Bool Source # (<=) :: Sum p q a b -> Sum p q a b -> Bool Source # (>) :: Sum p q a b -> Sum p q a b -> Bool Source # (>=) :: Sum p q a b -> Sum p q a b -> Bool Source # max :: Sum p q a b -> Sum p q a b -> Sum p q a b Source # min :: Sum p q a b -> Sum p q a b -> Sum p q a b Source #
( Ord (f a b), Ord (g a b)) => Ord ( Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods compare :: Product f g a b -> Product f g a b -> Ordering Source # (<) :: Product f g a b -> Product f g a b -> Bool Source # (<=) :: Product f g a b -> Product f g a b -> Bool Source # (>) :: Product f g a b -> Product f g a b -> Bool Source # (>=) :: Product f g a b -> Product f g a b -> Bool Source # max :: Product f g a b -> Product f g a b -> Product f g a b Source # min :: Product f g a b -> Product f g a b -> Product f g a b Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering Source # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) Source # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) Source #
Ord (f (p a b)) => Ord ( Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods compare :: Tannen f p a b -> Tannen f p a b -> Ordering Source # (<) :: Tannen f p a b -> Tannen f p a b -> Bool Source # (<=) :: Tannen f p a b -> Tannen f p a b -> Bool Source # (>) :: Tannen f p a b -> Tannen f p a b -> Bool Source # (>=) :: Tannen f p a b -> Tannen f p a b -> Bool Source # max :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b Source # min :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) Source # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) Source # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) Source #
Ord (p (f a) (g b)) => Ord ( Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods compare :: Biff p f g a b -> Biff p f g a b -> Ordering Source # (<) :: Biff p f g a b -> Biff p f g a b -> Bool Source # (<=) :: Biff p f g a b -> Biff p f g a b -> Bool Source # (>) :: Biff p f g a b -> Biff p f g a b -> Bool Source # (>=) :: Biff p f g a b -> Biff p f g a b -> Bool Source # max :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b Source # min :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) Source # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) Source # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool Source # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) Source # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool Source # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool Source # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #
( Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering Source # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool Source # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #

class Read a Source #

Parsing of String s, producing values.

Derived instances of Read make the following assumptions, which derived instances of Show obey:

If the constructor is defined to be an infix operator, then the derived Read instance will parse only infix applications of the constructor (not the prefix form).
Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
If the constructor is defined using record syntax, the derived Read will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
The derived Read instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.

For example, given the declarations

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

the derived instance of Read in Haskell 2010 is equivalent to

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

        readsPrec d r =  readParen (d > app_prec)
                         (\r -> [(Leaf m,t) |
                                 ("Leaf",s) <- lex r,
                                 (m,t) <- readsPrec (app_prec+1) s]) r

                      ++ readParen (d > up_prec)
                         (\r -> [(u:^:v,w) |
                                 (u,s) <- readsPrec (up_prec+1) r,
                                 (":^:",t) <- lex s,
                                 (v,w) <- readsPrec (up_prec+1) t]) r

          where app_prec = 10
                up_prec = 5

Note that right-associativity of :^: is unused.

The derived instance in GHC is equivalent to

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

        readPrec = parens $ (prec app_prec $ do
                                 Ident "Leaf" <- lexP
                                 m <- step readPrec
                                 return (Leaf m))

                     +++ (prec up_prec $ do
                                 u <- step readPrec
                                 Symbol ":^:" <- lexP
                                 v <- step readPrec
                                 return (u :^: v))

          where app_prec = 10
                up_prec = 5

        readListPrec = readListPrecDefault

Why do both readsPrec and readPrec exist, and why does GHC opt to implement readPrec in derived Read instances instead of readsPrec ? The reason is that readsPrec is based on the ReadS type, and although ReadS is mentioned in the Haskell 2010 Report, it is not a very efficient parser data structure.

readPrec , on the other hand, is based on a much more efficient ReadPrec datatype (a.k.a "new-style parsers"), but its definition relies on the use of the RankNTypes language extension. Therefore, readPrec (and its cousin, readListPrec ) are marked as GHC-only. Nevertheless, it is recommended to use readPrec instead of readsPrec whenever possible for the efficiency improvements it brings.

As mentioned above, derived Read instances in GHC will implement readPrec instead of readsPrec . The default implementations of readsPrec (and its cousin, readList ) will simply use readPrec under the hood. If you are writing a Read instance by hand, it is recommended to write it like so:

instance Read T where
  readPrec     = ...
  readListPrec = readListPrecDefault

Minimal complete definition

readsPrec | readPrec

Instances

Instances details

Read Bool	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Bool Source # readList :: ReadS [ Bool ] Source # readPrec :: ReadPrec Bool Source # readListPrec :: ReadPrec [ Bool ] Source #
Read Char	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char Source # readList :: ReadS [ Char ] Source # readPrec :: ReadPrec Char Source # readListPrec :: ReadPrec [ Char ] Source #
Read Double	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double Source # readList :: ReadS [ Double ] Source # readPrec :: ReadPrec Double Source # readListPrec :: ReadPrec [ Double ] Source #
Read Float	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float Source # readList :: ReadS [ Float ] Source # readPrec :: ReadPrec Float Source # readListPrec :: ReadPrec [ Float ] Source #
Read Int	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int Source # readList :: ReadS [ Int ] Source # readPrec :: ReadPrec Int Source # readListPrec :: ReadPrec [ Int ] Source #
Read Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int8 Source # readList :: ReadS [ Int8 ] Source # readPrec :: ReadPrec Int8 Source # readListPrec :: ReadPrec [ Int8 ] Source #
Read Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int16 Source # readList :: ReadS [ Int16 ] Source # readPrec :: ReadPrec Int16 Source # readListPrec :: ReadPrec [ Int16 ] Source #
Read Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int32 Source # readList :: ReadS [ Int32 ] Source # readPrec :: ReadPrec Int32 Source # readListPrec :: ReadPrec [ Int32 ] Source #
Read Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int64 Source # readList :: ReadS [ Int64 ] Source # readPrec :: ReadPrec Int64 Source # readListPrec :: ReadPrec [ Int64 ] Source #
Read Integer	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Integer Source # readList :: ReadS [ Integer ] Source # readPrec :: ReadPrec Integer Source # readListPrec :: ReadPrec [ Integer ] Source #
Read Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Natural Source # readList :: ReadS [ Natural ] Source # readPrec :: ReadPrec Natural Source # readListPrec :: ReadPrec [ Natural ] Source #
Read Ordering	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Ordering Source # readList :: ReadS [ Ordering ] Source # readPrec :: ReadPrec Ordering Source # readListPrec :: ReadPrec [ Ordering ] Source #
Read Word	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word Source # readList :: ReadS [ Word ] Source # readPrec :: ReadPrec Word Source # readListPrec :: ReadPrec [ Word ] Source #
Read Word8	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word8 Source # readList :: ReadS [ Word8 ] Source # readPrec :: ReadPrec Word8 Source # readListPrec :: ReadPrec [ Word8 ] Source #
Read Word16	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word16 Source # readList :: ReadS [ Word16 ] Source # readPrec :: ReadPrec Word16 Source # readListPrec :: ReadPrec [ Word16 ] Source #
Read Word32	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word32 Source # readList :: ReadS [ Word32 ] Source # readPrec :: ReadPrec Word32 Source # readListPrec :: ReadPrec [ Word32 ] Source #
Read Word64	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word64 Source # readList :: ReadS [ Word64 ] Source # readPrec :: ReadPrec Word64 Source # readListPrec :: ReadPrec [ Word64 ] Source #
Read ()	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS () Source # readList :: ReadS [()] Source # readPrec :: ReadPrec () Source # readListPrec :: ReadPrec [()] Source #
Read ByteString
Instance details Defined in Data.ByteString.Internal Methods readsPrec :: Int -> ReadS ByteString Source # readList :: ReadS [ ByteString ] Source # readPrec :: ReadPrec ByteString Source # readListPrec :: ReadPrec [ ByteString ] Source #
Read ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods readsPrec :: Int -> ReadS ByteString Source # readList :: ReadS [ ByteString ] Source # readPrec :: ReadPrec ByteString Source # readListPrec :: ReadPrec [ ByteString ] Source #
Read Scientific	Supports the skipping of parentheses and whitespaces. Example: > read " ( (( -1.0e+3 ) ))" :: Scientific -1000.0 (Note: This `Read` instance makes internal use of `scientificP` to parse the floating-point number.)
Instance details Defined in Data.Scientific Methods readsPrec :: Int -> ReadS Scientific Source # readList :: ReadS [ Scientific ] Source # readPrec :: ReadPrec Scientific Source # readListPrec :: ReadPrec [ Scientific ] Source #
Read Value
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS Value Source # readList :: ReadS [ Value ] Source # readPrec :: ReadPrec Value Source # readListPrec :: ReadPrec [ Value ] Source #
Read DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS DotNetTime Source # readList :: ReadS [ DotNetTime ] Source # readPrec :: ReadPrec DotNetTime Source # readListPrec :: ReadPrec [ DotNetTime ] Source #
Read Key
Instance details Defined in Data.Aeson.Key Methods readsPrec :: Int -> ReadS Key Source # readList :: ReadS [ Key ] Source # readPrec :: ReadPrec Key Source # readListPrec :: ReadPrec [ Key ] Source #
Read Void	Reading a `Void` value is always a parse error, considering `Void` as a data type with no constructors. Since: base-4.8.0.0
Instance details Defined in Data.Void Methods readsPrec :: Int -> ReadS Void Source # readList :: ReadS [ Void ] Source # readPrec :: ReadPrec Void Source # readListPrec :: ReadPrec [ Void ] Source #
Read Version	Since: base-2.1
Instance details Defined in Data.Version Methods readsPrec :: Int -> ReadS Version Source # readList :: ReadS [ Version ] Source # readPrec :: ReadPrec Version Source # readListPrec :: ReadPrec [ Version ] Source #
Read CDev
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CDev Source # readList :: ReadS [ CDev ] Source # readPrec :: ReadPrec CDev Source # readListPrec :: ReadPrec [ CDev ] Source #
Read CIno
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CIno Source # readList :: ReadS [ CIno ] Source # readPrec :: ReadPrec CIno Source # readListPrec :: ReadPrec [ CIno ] Source #
Read CMode
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CMode Source # readList :: ReadS [ CMode ] Source # readPrec :: ReadPrec CMode Source # readListPrec :: ReadPrec [ CMode ] Source #
Read COff
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS COff Source # readList :: ReadS [ COff ] Source # readPrec :: ReadPrec COff Source # readListPrec :: ReadPrec [ COff ] Source #
Read CPid
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CPid Source # readList :: ReadS [ CPid ] Source # readPrec :: ReadPrec CPid Source # readListPrec :: ReadPrec [ CPid ] Source #
Read CSsize
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CSsize Source # readList :: ReadS [ CSsize ] Source # readPrec :: ReadPrec CSsize Source # readListPrec :: ReadPrec [ CSsize ] Source #
Read CGid
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CGid Source # readList :: ReadS [ CGid ] Source # readPrec :: ReadPrec CGid Source # readListPrec :: ReadPrec [ CGid ] Source #
Read CNlink
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CNlink Source # readList :: ReadS [ CNlink ] Source # readPrec :: ReadPrec CNlink Source # readListPrec :: ReadPrec [ CNlink ] Source #
Read CUid
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CUid Source # readList :: ReadS [ CUid ] Source # readPrec :: ReadPrec CUid Source # readListPrec :: ReadPrec [ CUid ] Source #
Read CCc
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CCc Source # readList :: ReadS [ CCc ] Source # readPrec :: ReadPrec CCc Source # readListPrec :: ReadPrec [ CCc ] Source #
Read CSpeed
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CSpeed Source # readList :: ReadS [ CSpeed ] Source # readPrec :: ReadPrec CSpeed Source # readListPrec :: ReadPrec [ CSpeed ] Source #
Read CTcflag
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CTcflag Source # readList :: ReadS [ CTcflag ] Source # readPrec :: ReadPrec CTcflag Source # readListPrec :: ReadPrec [ CTcflag ] Source #
Read CRLim
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CRLim Source # readList :: ReadS [ CRLim ] Source # readPrec :: ReadPrec CRLim Source # readListPrec :: ReadPrec [ CRLim ] Source #
Read CBlkSize
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CBlkSize Source # readList :: ReadS [ CBlkSize ] Source # readPrec :: ReadPrec CBlkSize Source # readListPrec :: ReadPrec [ CBlkSize ] Source #
Read CBlkCnt
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CBlkCnt Source # readList :: ReadS [ CBlkCnt ] Source # readPrec :: ReadPrec CBlkCnt Source # readListPrec :: ReadPrec [ CBlkCnt ] Source #
Read CClockId
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CClockId Source # readList :: ReadS [ CClockId ] Source # readPrec :: ReadPrec CClockId Source # readListPrec :: ReadPrec [ CClockId ] Source #
Read CFsBlkCnt
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CFsBlkCnt Source # readList :: ReadS [ CFsBlkCnt ] Source # readPrec :: ReadPrec CFsBlkCnt Source # readListPrec :: ReadPrec [ CFsBlkCnt ] Source #
Read CFsFilCnt
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CFsFilCnt Source # readList :: ReadS [ CFsFilCnt ] Source # readPrec :: ReadPrec CFsFilCnt Source # readListPrec :: ReadPrec [ CFsFilCnt ] Source #
Read CId
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CId Source # readList :: ReadS [ CId ] Source # readPrec :: ReadPrec CId Source # readListPrec :: ReadPrec [ CId ] Source #
Read CKey
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CKey Source # readList :: ReadS [ CKey ] Source # readPrec :: ReadPrec CKey Source # readListPrec :: ReadPrec [ CKey ] Source #
Read CSocklen
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CSocklen Source # readList :: ReadS [ CSocklen ] Source # readPrec :: ReadPrec CSocklen Source # readListPrec :: ReadPrec [ CSocklen ] Source #
Read CNfds
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS CNfds Source # readList :: ReadS [ CNfds ] Source # readPrec :: ReadPrec CNfds Source # readListPrec :: ReadPrec [ CNfds ] Source #
Read Fd
Instance details Defined in System.Posix.Types Methods readsPrec :: Int -> ReadS Fd Source # readList :: ReadS [ Fd ] Source # readPrec :: ReadPrec Fd Source # readListPrec :: ReadPrec [ Fd ] Source #
Read ExitCode
Instance details Defined in GHC.IO.Exception Methods readsPrec :: Int -> ReadS ExitCode Source # readList :: ReadS [ ExitCode ] Source # readPrec :: ReadPrec ExitCode Source # readListPrec :: ReadPrec [ ExitCode ] Source #
Read BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods readsPrec :: Int -> ReadS BufferMode Source # readList :: ReadS [ BufferMode ] Source # readPrec :: ReadPrec BufferMode Source # readListPrec :: ReadPrec [ BufferMode ] Source #
Read Newline	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods readsPrec :: Int -> ReadS Newline Source # readList :: ReadS [ Newline ] Source # readPrec :: ReadPrec Newline Source # readListPrec :: ReadPrec [ Newline ] Source #
Read NewlineMode	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods readsPrec :: Int -> ReadS NewlineMode Source # readList :: ReadS [ NewlineMode ] Source # readPrec :: ReadPrec NewlineMode Source # readListPrec :: ReadPrec [ NewlineMode ] Source #
Read All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS All Source # readList :: ReadS [ All ] Source # readPrec :: ReadPrec All Source # readListPrec :: ReadPrec [ All ] Source #
Read Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS Any Source # readList :: ReadS [ Any ] Source # readPrec :: ReadPrec Any Source # readListPrec :: ReadPrec [ Any ] Source #
Read Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Fixity Source # readList :: ReadS [ Fixity ] Source # readPrec :: ReadPrec Fixity Source # readListPrec :: ReadPrec [ Fixity ] Source #
Read Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Associativity Source # readList :: ReadS [ Associativity ] Source # readPrec :: ReadPrec Associativity Source # readListPrec :: ReadPrec [ Associativity ] Source #
Read SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS SourceUnpackedness Source # readList :: ReadS [ SourceUnpackedness ] Source # readPrec :: ReadPrec SourceUnpackedness Source # readListPrec :: ReadPrec [ SourceUnpackedness ] Source #
Read SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS SourceStrictness Source # readList :: ReadS [ SourceStrictness ] Source # readPrec :: ReadPrec SourceStrictness Source # readListPrec :: ReadPrec [ SourceStrictness ] Source #
Read DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS DecidedStrictness Source # readList :: ReadS [ DecidedStrictness ] Source # readPrec :: ReadPrec DecidedStrictness Source # readListPrec :: ReadPrec [ DecidedStrictness ] Source #
Read SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods readsPrec :: Int -> ReadS SomeSymbol Source # readList :: ReadS [ SomeSymbol ] Source # readPrec :: ReadPrec SomeSymbol Source # readListPrec :: ReadPrec [ SomeSymbol ] Source #
Read SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods readsPrec :: Int -> ReadS SomeNat Source # readList :: ReadS [ SomeNat ] Source # readPrec :: ReadPrec SomeNat Source # readListPrec :: ReadPrec [ SomeNat ] Source #
Read CChar
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CChar Source # readList :: ReadS [ CChar ] Source # readPrec :: ReadPrec CChar Source # readListPrec :: ReadPrec [ CChar ] Source #
Read CSChar
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CSChar Source # readList :: ReadS [ CSChar ] Source # readPrec :: ReadPrec CSChar Source # readListPrec :: ReadPrec [ CSChar ] Source #
Read CUChar
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUChar Source # readList :: ReadS [ CUChar ] Source # readPrec :: ReadPrec CUChar Source # readListPrec :: ReadPrec [ CUChar ] Source #
Read CShort
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CShort Source # readList :: ReadS [ CShort ] Source # readPrec :: ReadPrec CShort Source # readListPrec :: ReadPrec [ CShort ] Source #
Read CUShort
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUShort Source # readList :: ReadS [ CUShort ] Source # readPrec :: ReadPrec CUShort Source # readListPrec :: ReadPrec [ CUShort ] Source #
Read CInt
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CInt Source # readList :: ReadS [ CInt ] Source # readPrec :: ReadPrec CInt Source # readListPrec :: ReadPrec [ CInt ] Source #
Read CUInt
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUInt Source # readList :: ReadS [ CUInt ] Source # readPrec :: ReadPrec CUInt Source # readListPrec :: ReadPrec [ CUInt ] Source #
Read CLong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CLong Source # readList :: ReadS [ CLong ] Source # readPrec :: ReadPrec CLong Source # readListPrec :: ReadPrec [ CLong ] Source #
Read CULong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CULong Source # readList :: ReadS [ CULong ] Source # readPrec :: ReadPrec CULong Source # readListPrec :: ReadPrec [ CULong ] Source #
Read CLLong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CLLong Source # readList :: ReadS [ CLLong ] Source # readPrec :: ReadPrec CLLong Source # readListPrec :: ReadPrec [ CLLong ] Source #
Read CULLong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CULLong Source # readList :: ReadS [ CULLong ] Source # readPrec :: ReadPrec CULLong Source # readListPrec :: ReadPrec [ CULLong ] Source #
Read CBool
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CBool Source # readList :: ReadS [ CBool ] Source # readPrec :: ReadPrec CBool Source # readListPrec :: ReadPrec [ CBool ] Source #
Read CFloat
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CFloat Source # readList :: ReadS [ CFloat ] Source # readPrec :: ReadPrec CFloat Source # readListPrec :: ReadPrec [ CFloat ] Source #
Read CDouble
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CDouble Source # readList :: ReadS [ CDouble ] Source # readPrec :: ReadPrec CDouble Source # readListPrec :: ReadPrec [ CDouble ] Source #
Read CPtrdiff
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CPtrdiff Source # readList :: ReadS [ CPtrdiff ] Source # readPrec :: ReadPrec CPtrdiff Source # readListPrec :: ReadPrec [ CPtrdiff ] Source #
Read CSize
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CSize Source # readList :: ReadS [ CSize ] Source # readPrec :: ReadPrec CSize Source # readListPrec :: ReadPrec [ CSize ] Source #
Read CWchar
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CWchar Source # readList :: ReadS [ CWchar ] Source # readPrec :: ReadPrec CWchar Source # readListPrec :: ReadPrec [ CWchar ] Source #
Read CSigAtomic
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CSigAtomic Source # readList :: ReadS [ CSigAtomic ] Source # readPrec :: ReadPrec CSigAtomic Source # readListPrec :: ReadPrec [ CSigAtomic ] Source #
Read CClock
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CClock Source # readList :: ReadS [ CClock ] Source # readPrec :: ReadPrec CClock Source # readListPrec :: ReadPrec [ CClock ] Source #
Read CTime
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CTime Source # readList :: ReadS [ CTime ] Source # readPrec :: ReadPrec CTime Source # readListPrec :: ReadPrec [ CTime ] Source #
Read CUSeconds
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUSeconds Source # readList :: ReadS [ CUSeconds ] Source # readPrec :: ReadPrec CUSeconds Source # readListPrec :: ReadPrec [ CUSeconds ] Source #
Read CSUSeconds
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CSUSeconds Source # readList :: ReadS [ CSUSeconds ] Source # readPrec :: ReadPrec CSUSeconds Source # readListPrec :: ReadPrec [ CSUSeconds ] Source #
Read CIntPtr
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CIntPtr Source # readList :: ReadS [ CIntPtr ] Source # readPrec :: ReadPrec CIntPtr Source # readListPrec :: ReadPrec [ CIntPtr ] Source #
Read CUIntPtr
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUIntPtr Source # readList :: ReadS [ CUIntPtr ] Source # readPrec :: ReadPrec CUIntPtr Source # readListPrec :: ReadPrec [ CUIntPtr ] Source #
Read CIntMax
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CIntMax Source # readList :: ReadS [ CIntMax ] Source # readPrec :: ReadPrec CIntMax Source # readListPrec :: ReadPrec [ CIntMax ] Source #
Read CUIntMax
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUIntMax Source # readList :: ReadS [ CUIntMax ] Source # readPrec :: ReadPrec CUIntMax Source # readListPrec :: ReadPrec [ CUIntMax ] Source #
Read WordPtr
Instance details Defined in Foreign.Ptr Methods readsPrec :: Int -> ReadS WordPtr Source # readList :: ReadS [ WordPtr ] Source # readPrec :: ReadPrec WordPtr Source # readListPrec :: ReadPrec [ WordPtr ] Source #
Read IntPtr
Instance details Defined in Foreign.Ptr Methods readsPrec :: Int -> ReadS IntPtr Source # readList :: ReadS [ IntPtr ] Source # readPrec :: ReadPrec IntPtr Source # readListPrec :: ReadPrec [ IntPtr ] Source #
Read IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods readsPrec :: Int -> ReadS IOMode Source # readList :: ReadS [ IOMode ] Source # readPrec :: ReadPrec IOMode Source # readListPrec :: ReadPrec [ IOMode ] Source #
Read Lexeme	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Lexeme Source # readList :: ReadS [ Lexeme ] Source # readPrec :: ReadPrec Lexeme Source # readListPrec :: ReadPrec [ Lexeme ] Source #
Read GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS GeneralCategory Source # readList :: ReadS [ GeneralCategory ] Source # readPrec :: ReadPrec GeneralCategory Source # readListPrec :: ReadPrec [ GeneralCategory ] Source #
Read ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods readsPrec :: Int -> ReadS ShortByteString Source # readList :: ReadS [ ShortByteString ] Source # readPrec :: ReadPrec ShortByteString Source # readListPrec :: ReadPrec [ ShortByteString ] Source #
Read JSValue
Instance details Defined in Text.JSON.Canonical.Types Methods readsPrec :: Int -> ReadS JSValue Source # readList :: ReadS [ JSValue ] Source # readPrec :: ReadPrec JSValue Source # readListPrec :: ReadPrec [ JSValue ] Source #
Read JSString
Instance details Defined in Text.JSON.Canonical.Types Methods readsPrec :: Int -> ReadS JSString Source # readList :: ReadS [ JSString ] Source # readPrec :: ReadPrec JSString Source # readListPrec :: ReadPrec [ JSString ] Source #
Read Int54
Instance details Defined in Text.JSON.Canonical.Types Methods readsPrec :: Int -> ReadS Int54 Source # readList :: ReadS [ Int54 ] Source # readPrec :: ReadPrec Int54 Source # readListPrec :: ReadPrec [ Int54 ] Source #
Read IntSet
Instance details Defined in Data.IntSet.Internal Methods readsPrec :: Int -> ReadS IntSet Source # readList :: ReadS [ IntSet ] Source # readPrec :: ReadPrec IntSet Source # readListPrec :: ReadPrec [ IntSet ] Source #
Read ShortText
Instance details Defined in Data.Text.Short.Internal Methods readsPrec :: Int -> ReadS ShortText Source # readList :: ReadS [ ShortText ] Source # readPrec :: ReadPrec ShortText Source # readListPrec :: ReadPrec [ ShortText ] Source #
Read UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods readsPrec :: Int -> ReadS UnpackedUUID Source # readList :: ReadS [UnpackedUUID] Source # readPrec :: ReadPrec UnpackedUUID Source # readListPrec :: ReadPrec [UnpackedUUID] Source #
Read UUID
Instance details Defined in Data.UUID.Types.Internal Methods readsPrec :: Int -> ReadS UUID Source # readList :: ReadS [ UUID ] Source # readPrec :: ReadPrec UUID Source # readListPrec :: ReadPrec [ UUID ] Source #
Read a => Read [a]	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS [a] Source # readList :: ReadS [[a]] Source # readPrec :: ReadPrec [a] Source # readListPrec :: ReadPrec [[a]] Source #
Read a => Read ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS ( Maybe a) Source # readList :: ReadS [ Maybe a] Source # readPrec :: ReadPrec ( Maybe a) Source # readListPrec :: ReadPrec [ Maybe a] Source #
( Integral a, Read a) => Read ( Ratio a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS ( Ratio a) Source # readList :: ReadS [ Ratio a] Source # readPrec :: ReadPrec ( Ratio a) Source # readListPrec :: ReadPrec [ Ratio a] Source #
Read p => Read ( Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( Par1 p) Source # readList :: ReadS [ Par1 p] Source # readPrec :: ReadPrec ( Par1 p) Source # readListPrec :: ReadPrec [ Par1 p] Source #
Read a => Read ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods readsPrec :: Int -> ReadS ( Solo a) Source # readList :: ReadS [ Solo a] Source # readPrec :: ReadPrec ( Solo a) Source # readListPrec :: ReadPrec [ Solo a] Source #
Read v => Read ( KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods readsPrec :: Int -> ReadS ( KeyMap v) Source # readList :: ReadS [ KeyMap v] Source # readPrec :: ReadPrec ( KeyMap v) Source # readListPrec :: ReadPrec [ KeyMap v] Source #
Read a => Read ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods readsPrec :: Int -> ReadS ( Complex a) Source # readList :: ReadS [ Complex a] Source # readPrec :: ReadPrec ( Complex a) Source # readListPrec :: ReadPrec [ Complex a] Source #
Read a => Read ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( Min a) Source # readList :: ReadS [ Min a] Source # readPrec :: ReadPrec ( Min a) Source # readListPrec :: ReadPrec [ Min a] Source #
Read a => Read ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( Max a) Source # readList :: ReadS [ Max a] Source # readPrec :: ReadPrec ( Max a) Source # readListPrec :: ReadPrec [ Max a] Source #
Read a => Read ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( First a) Source # readList :: ReadS [ First a] Source # readPrec :: ReadPrec ( First a) Source # readListPrec :: ReadPrec [ First a] Source #
Read a => Read ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( Last a) Source # readList :: ReadS [ Last a] Source # readPrec :: ReadPrec ( Last a) Source # readListPrec :: ReadPrec [ Last a] Source #
Read m => Read ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( WrappedMonoid m) Source # readList :: ReadS [ WrappedMonoid m] Source # readPrec :: ReadPrec ( WrappedMonoid m) Source # readListPrec :: ReadPrec [ WrappedMonoid m] Source #
Read a => Read ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( Option a) Source # readList :: ReadS [ Option a] Source # readPrec :: ReadPrec ( Option a) Source # readListPrec :: ReadPrec [ Option a] Source #
Read a => Read ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods readsPrec :: Int -> ReadS ( ZipList a) Source # readList :: ReadS [ ZipList a] Source # readPrec :: ReadPrec ( ZipList a) Source # readListPrec :: ReadPrec [ ZipList a] Source #
Read a => Read ( Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS ( Identity a) Source # readList :: ReadS [ Identity a] Source # readPrec :: ReadPrec ( Identity a) Source # readListPrec :: ReadPrec [ Identity a] Source #
Read a => Read ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS ( First a) Source # readList :: ReadS [ First a] Source # readPrec :: ReadPrec ( First a) Source # readListPrec :: ReadPrec [ First a] Source #
Read a => Read ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS ( Last a) Source # readList :: ReadS [ Last a] Source # readPrec :: ReadPrec ( Last a) Source # readListPrec :: ReadPrec [ Last a] Source #
Read a => Read ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Dual a) Source # readList :: ReadS [ Dual a] Source # readPrec :: ReadPrec ( Dual a) Source # readListPrec :: ReadPrec [ Dual a] Source #
Read a => Read ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Sum a) Source # readList :: ReadS [ Sum a] Source # readPrec :: ReadPrec ( Sum a) Source # readListPrec :: ReadPrec [ Sum a] Source #
Read a => Read ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Product a) Source # readList :: ReadS [ Product a] Source # readPrec :: ReadPrec ( Product a) Source # readListPrec :: ReadPrec [ Product a] Source #
Read a => Read ( Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods readsPrec :: Int -> ReadS ( Down a) Source # readList :: ReadS [ Down a] Source # readPrec :: ReadPrec ( Down a) Source # readListPrec :: ReadPrec [ Down a] Source #
Read a => Read ( NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS ( NonEmpty a) Source # readList :: ReadS [ NonEmpty a] Source # readPrec :: ReadPrec ( NonEmpty a) Source # readListPrec :: ReadPrec [ NonEmpty a] Source #
Read e => Read ( IntMap e)
Instance details Defined in Data.IntMap.Internal Methods readsPrec :: Int -> ReadS ( IntMap e) Source # readList :: ReadS [ IntMap e] Source # readPrec :: ReadPrec ( IntMap e) Source # readListPrec :: ReadPrec [ IntMap e] Source #
Read a => Read ( Tree a)
Instance details Defined in Data.Tree Methods readsPrec :: Int -> ReadS ( Tree a) Source # readList :: ReadS [ Tree a] Source # readPrec :: ReadPrec ( Tree a) Source # readListPrec :: ReadPrec [ Tree a] Source #
Read a => Read ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS ( Seq a) Source # readList :: ReadS [ Seq a] Source # readPrec :: ReadPrec ( Seq a) Source # readListPrec :: ReadPrec [ Seq a] Source #
Read a => Read ( ViewL a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS ( ViewL a) Source # readList :: ReadS [ ViewL a] Source # readPrec :: ReadPrec ( ViewL a) Source # readListPrec :: ReadPrec [ ViewL a] Source #
Read a => Read ( ViewR a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS ( ViewR a) Source # readList :: ReadS [ ViewR a] Source # readPrec :: ReadPrec ( ViewR a) Source # readListPrec :: ReadPrec [ ViewR a] Source #
( Read a, Ord a) => Read ( Set a)
Instance details Defined in Data.Set.Internal Methods readsPrec :: Int -> ReadS ( Set a) Source # readList :: ReadS [ Set a] Source # readPrec :: ReadPrec ( Set a) Source # readListPrec :: ReadPrec [ Set a] Source #
Read1 f => Read ( Fix f)
Instance details Defined in Data.Fix Methods readsPrec :: Int -> ReadS ( Fix f) Source # readList :: ReadS [ Fix f] Source # readPrec :: ReadPrec ( Fix f) Source # readListPrec :: ReadPrec [ Fix f] Source #
( Functor f, Read1 f) => Read ( Mu f)
Instance details Defined in Data.Fix Methods readsPrec :: Int -> ReadS ( Mu f) Source # readList :: ReadS [ Mu f] Source # readPrec :: ReadPrec ( Mu f) Source # readListPrec :: ReadPrec [ Mu f] Source #
( Functor f, Read1 f) => Read ( Nu f)
Instance details Defined in Data.Fix Methods readsPrec :: Int -> ReadS ( Nu f) Source # readList :: ReadS [ Nu f] Source # readPrec :: ReadPrec ( Nu f) Source # readListPrec :: ReadPrec [ Nu f] Source #
Read a => Read ( DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods readsPrec :: Int -> ReadS ( DNonEmpty a) Source # readList :: ReadS [ DNonEmpty a] Source # readPrec :: ReadPrec ( DNonEmpty a) Source # readListPrec :: ReadPrec [ DNonEmpty a] Source #
Read a => Read ( DList a)
Instance details Defined in Data.DList.Internal Methods readsPrec :: Int -> ReadS ( DList a) Source # readList :: ReadS [ DList a] Source # readPrec :: ReadPrec ( DList a) Source # readListPrec :: ReadPrec [ DList a] Source #
Read a => Read ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods readsPrec :: Int -> ReadS ( Hex a) Source # readList :: ReadS [ Hex a] Source # readPrec :: ReadPrec ( Hex a) Source # readListPrec :: ReadPrec [ Hex a] Source #
Read a => Read ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods readsPrec :: Int -> ReadS ( Shown a) Source # readList :: ReadS [ Shown a] Source # readPrec :: ReadPrec ( Shown a) Source # readListPrec :: ReadPrec [ Shown a] Source #
Read a => Read ( SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods readsPrec :: Int -> ReadS ( SmallArray a) Source # readList :: ReadS [ SmallArray a] Source # readPrec :: ReadPrec ( SmallArray a) Source # readListPrec :: ReadPrec [ SmallArray a] Source #
Read a => Read ( Array a)
Instance details Defined in Data.Primitive.Array Methods readsPrec :: Int -> ReadS ( Array a) Source # readList :: ReadS [ Array a] Source # readPrec :: ReadPrec ( Array a) Source # readListPrec :: ReadPrec [ Array a] Source #
Read a => Read ( Maybe a)
Instance details Defined in Data.Strict.Maybe Methods readsPrec :: Int -> ReadS ( Maybe a) Source # readList :: ReadS [ Maybe a] Source # readPrec :: ReadPrec ( Maybe a) Source # readListPrec :: ReadPrec [ Maybe a] Source #
( Eq a, Hashable a, Read a) => Read ( HashSet a)
Instance details Defined in Data.HashSet.Internal Methods readsPrec :: Int -> ReadS ( HashSet a) Source # readList :: ReadS [ HashSet a] Source # readPrec :: ReadPrec ( HashSet a) Source # readListPrec :: ReadPrec [ HashSet a] Source #
( Read a, Storable a) => Read ( Vector a)
Instance details Defined in Data.Vector.Storable Methods readsPrec :: Int -> ReadS ( Vector a) Source # readList :: ReadS [ Vector a] Source # readPrec :: ReadPrec ( Vector a) Source # readListPrec :: ReadPrec [ Vector a] Source #
( Read a, Prim a) => Read ( Vector a)
Instance details Defined in Data.Vector.Primitive Methods readsPrec :: Int -> ReadS ( Vector a) Source # readList :: ReadS [ Vector a] Source # readPrec :: ReadPrec ( Vector a) Source # readListPrec :: ReadPrec [ Vector a] Source #
Read a => Read ( Vector a)
Instance details Defined in Data.Vector Methods readsPrec :: Int -> ReadS ( Vector a) Source # readList :: ReadS [ Vector a] Source # readPrec :: ReadPrec ( Vector a) Source # readListPrec :: ReadPrec [ Vector a] Source #
( Read a, Read b) => Read ( Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods readsPrec :: Int -> ReadS ( Either a b) Source # readList :: ReadS [ Either a b] Source # readPrec :: ReadPrec ( Either a b) Source # readListPrec :: ReadPrec [ Either a b] Source #
Read ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( V1 p) Source # readList :: ReadS [ V1 p] Source # readPrec :: ReadPrec ( V1 p) Source # readListPrec :: ReadPrec [ V1 p] Source #
Read ( U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( U1 p) Source # readList :: ReadS [ U1 p] Source # readPrec :: ReadPrec ( U1 p) Source # readListPrec :: ReadPrec [ U1 p] Source #
( Read a, Read b) => Read (a, b)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b) Source # readList :: ReadS [(a, b)] Source # readPrec :: ReadPrec (a, b) Source # readListPrec :: ReadPrec [(a, b)] Source #
( Ord k, Read k, Read e) => Read ( Map k e)
Instance details Defined in Data.Map.Internal Methods readsPrec :: Int -> ReadS ( Map k e) Source # readList :: ReadS [ Map k e] Source # readPrec :: ReadPrec ( Map k e) Source # readListPrec :: ReadPrec [ Map k e] Source #
( Eq k, Hashable k, Read k, Read e) => Read ( HashMap k e)
Instance details Defined in Data.HashMap.Internal Methods readsPrec :: Int -> ReadS ( HashMap k e) Source # readList :: ReadS [ HashMap k e] Source # readPrec :: ReadPrec ( HashMap k e) Source # readListPrec :: ReadPrec [ HashMap k e] Source #
( Ix ix, Read ix, Read e, IArray UArray e) => Read ( UArray ix e)
Instance details Defined in Data.Array.Base Methods readsPrec :: Int -> ReadS ( UArray ix e) Source # readList :: ReadS [ UArray ix e] Source # readPrec :: ReadPrec ( UArray ix e) Source # readListPrec :: ReadPrec [ UArray ix e] Source #
( Ix a, Read a, Read b) => Read ( Array a b)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS ( Array a b) Source # readList :: ReadS [ Array a b] Source # readPrec :: ReadPrec ( Array a b) Source # readListPrec :: ReadPrec [ Array a b] Source #
HasResolution a => Read ( Fixed a)	Since: base-4.3.0.0
Instance details Defined in Data.Fixed Methods readsPrec :: Int -> ReadS ( Fixed a) Source # readList :: ReadS [ Fixed a] Source # readPrec :: ReadPrec ( Fixed a) Source # readListPrec :: ReadPrec [ Fixed a] Source #
( Read a, Read b) => Read ( Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( Arg a b) Source # readList :: ReadS [ Arg a b] Source # readPrec :: ReadPrec ( Arg a b) Source # readListPrec :: ReadPrec [ Arg a b] Source #
Read ( Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods readsPrec :: Int -> ReadS ( Proxy t) Source # readList :: ReadS [ Proxy t] Source # readPrec :: ReadPrec ( Proxy t) Source # readListPrec :: ReadPrec [ Proxy t] Source #
( Read1 m, Read a) => Read ( ListT m a)
Instance details Defined in Control.Monad.Trans.List Methods readsPrec :: Int -> ReadS ( ListT m a) Source # readList :: ReadS [ ListT m a] Source # readPrec :: ReadPrec ( ListT m a) Source # readListPrec :: ReadPrec [ ListT m a] Source #
( Read a, Read b) => Read ( These a b)
Instance details Defined in Data.These Methods readsPrec :: Int -> ReadS ( These a b) Source # readList :: ReadS [ These a b] Source # readPrec :: ReadPrec ( These a b) Source # readListPrec :: ReadPrec [ These a b] Source #
( Read a, Read b) => Read ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods readsPrec :: Int -> ReadS ( Pair a b) Source # readList :: ReadS [ Pair a b] Source # readPrec :: ReadPrec ( Pair a b) Source # readListPrec :: ReadPrec [ Pair a b] Source #
( Read a, Read b) => Read ( These a b)
Instance details Defined in Data.Strict.These Methods readsPrec :: Int -> ReadS ( These a b) Source # readList :: ReadS [ These a b] Source # readPrec :: ReadPrec ( These a b) Source # readListPrec :: ReadPrec [ These a b] Source #
( Read a, Read b) => Read ( Either a b)
Instance details Defined in Data.Strict.Either Methods readsPrec :: Int -> ReadS ( Either a b) Source # readList :: ReadS [ Either a b] Source # readPrec :: ReadPrec ( Either a b) Source # readListPrec :: ReadPrec [ Either a b] Source #
( Read1 m, Read a) => Read ( MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods readsPrec :: Int -> ReadS ( MaybeT m a) Source # readList :: ReadS [ MaybeT m a] Source # readPrec :: ReadPrec ( MaybeT m a) Source # readListPrec :: ReadPrec [ MaybeT m a] Source #
Read (f p) => Read ( Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( Rec1 f p) Source # readList :: ReadS [ Rec1 f p] Source # readPrec :: ReadPrec ( Rec1 f p) Source # readListPrec :: ReadPrec [ Rec1 f p] Source #
( Read a, Read b, Read c) => Read (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c) Source # readList :: ReadS [(a, b, c)] Source # readPrec :: ReadPrec (a, b, c) Source # readListPrec :: ReadPrec [(a, b, c)] Source #
Read a => Read ( 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 readsPrec :: Int -> ReadS ( Const a b) Source # readList :: ReadS [ Const a b] Source # readPrec :: ReadPrec ( Const a b) Source # readListPrec :: ReadPrec [ Const a b] Source #
Read (f a) => Read ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS ( Ap f a) Source # readList :: ReadS [ Ap f a] Source # readPrec :: ReadPrec ( Ap f a) Source # readListPrec :: ReadPrec [ Ap f a] Source #
Read (f a) => Read ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Alt f a) Source # readList :: ReadS [ Alt f a] Source # readPrec :: ReadPrec ( Alt f a) Source # readListPrec :: ReadPrec [ Alt f a] Source #
Coercible a b => Read ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods readsPrec :: Int -> ReadS ( Coercion a b) Source # readList :: ReadS [ Coercion a b] Source # readPrec :: ReadPrec ( Coercion a b) Source # readListPrec :: ReadPrec [ Coercion a b] Source #
a ~ b => Read (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods readsPrec :: Int -> ReadS (a :~: b) Source # readList :: ReadS [a :~: b] Source # readPrec :: ReadPrec (a :~: b) Source # readListPrec :: ReadPrec [a :~: b] Source #
( Read1 f, Read a) => Read ( IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods readsPrec :: Int -> ReadS ( IdentityT f a) Source # readList :: ReadS [ IdentityT f a] Source # readPrec :: ReadPrec ( IdentityT f a) Source # readListPrec :: ReadPrec [ IdentityT f a] Source #
( Read e, Read1 m, Read a) => Read ( ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods readsPrec :: Int -> ReadS ( ErrorT e m a) Source # readList :: ReadS [ ErrorT e m a] Source # readPrec :: ReadPrec ( ErrorT e m a) Source # readListPrec :: ReadPrec [ ErrorT e m a] Source #
( Read e, Read1 m, Read a) => Read ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods readsPrec :: Int -> ReadS ( ExceptT e m a) Source # readList :: ReadS [ ExceptT e m a] Source # readPrec :: ReadPrec ( ExceptT e m a) Source # readListPrec :: ReadPrec [ ExceptT e m a] Source #
( Read w, Read1 m, Read a) => Read ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods readsPrec :: Int -> ReadS ( WriterT w m a) Source # readList :: ReadS [ WriterT w m a] Source # readPrec :: ReadPrec ( WriterT w m a) Source # readListPrec :: ReadPrec [ WriterT w m a] Source #
( Read w, Read1 m, Read a) => Read ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods readsPrec :: Int -> ReadS ( WriterT w m a) Source # readList :: ReadS [ WriterT w m a] Source # readPrec :: ReadPrec ( WriterT w m a) Source # readListPrec :: ReadPrec [ WriterT w m a] Source #
Read b => Read ( Tagged s b)
Instance details Defined in Data.Tagged Methods readsPrec :: Int -> ReadS ( Tagged s b) Source # readList :: ReadS [ Tagged s b] Source # readPrec :: ReadPrec ( Tagged s b) Source # readListPrec :: ReadPrec [ Tagged s b] Source #
( Read1 f, Read1 g, Read a) => Read ( These1 f g a)
Instance details Defined in Data.Functor.These Methods readsPrec :: Int -> ReadS ( These1 f g a) Source # readList :: ReadS [ These1 f g a] Source # readPrec :: ReadPrec ( These1 f g a) Source # readListPrec :: ReadPrec [ These1 f g a] Source #
Read c => Read ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( K1 i c p) Source # readList :: ReadS [ K1 i c p] Source # readPrec :: ReadPrec ( K1 i c p) Source # readListPrec :: ReadPrec [ K1 i c p] Source #
( Read (f p), Read (g p)) => Read ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :+: g) p) Source # readList :: ReadS [(f :+: g) p] Source # readPrec :: ReadPrec ((f :+: g) p) Source # readListPrec :: ReadPrec [(f :+: g) p] Source #
( Read (f p), Read (g p)) => Read ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :: g) p) Source # readList :: ReadS [(f :: g) p] Source # readPrec :: ReadPrec ((f :: g) p) Source # readListPrec :: ReadPrec [(f :: g) p] Source #
( Read a, Read b, Read c, Read d) => Read (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d) Source # readList :: ReadS [(a, b, c, d)] Source # readPrec :: ReadPrec (a, b, c, d) Source # readListPrec :: ReadPrec [(a, b, c, d)] Source #
( Read1 f, Read1 g, Read a) => Read ( Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods readsPrec :: Int -> ReadS ( Product f g a) Source # readList :: ReadS [ Product f g a] Source # readPrec :: ReadPrec ( Product f g a) Source # readListPrec :: ReadPrec [ Product f g a] Source #
( Read1 f, Read1 g, Read a) => Read ( Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods readsPrec :: Int -> ReadS ( Sum f g a) Source # readList :: ReadS [ Sum f g a] Source # readPrec :: ReadPrec ( Sum f g a) Source # readListPrec :: ReadPrec [ Sum f g a] Source #
a ~~ b => Read (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods readsPrec :: Int -> ReadS (a :~~: b) Source # readList :: ReadS [a :~~: b] Source # readPrec :: ReadPrec (a :~~: b) Source # readListPrec :: ReadPrec [a :~~: b] Source #
Read (f p) => Read ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( M1 i c f p) Source # readList :: ReadS [ M1 i c f p] Source # readPrec :: ReadPrec ( M1 i c f p) Source # readListPrec :: ReadPrec [ M1 i c f p] Source #
Read (f (g p)) => Read ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :.: g) p) Source # readList :: ReadS [(f :.: g) p] Source # readPrec :: ReadPrec ((f :.: g) p) Source # readListPrec :: ReadPrec [(f :.: g) p] Source #
( Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e) Source # readList :: ReadS [(a, b, c, d, e)] Source # readPrec :: ReadPrec (a, b, c, d, e) Source # readListPrec :: ReadPrec [(a, b, c, d, e)] Source #
( Read1 f, Read1 g, Read a) => Read ( Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods readsPrec :: Int -> ReadS ( Compose f g a) Source # readList :: ReadS [ Compose f g a] Source # readPrec :: ReadPrec ( Compose f g a) Source # readListPrec :: ReadPrec [ Compose f g a] Source #
Read (p b a) => Read ( Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods readsPrec :: Int -> ReadS ( Flip p a b) Source # readList :: ReadS [ Flip p a b] Source # readPrec :: ReadPrec ( Flip p a b) Source # readListPrec :: ReadPrec [ Flip p a b] Source #
( Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f) Source # readList :: ReadS [(a, b, c, d, e, f)] Source # readPrec :: ReadPrec (a, b, c, d, e, f) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f)] Source #
( Read (p a b), Read (q a b)) => Read ( Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods readsPrec :: Int -> ReadS ( Sum p q a b) Source # readList :: ReadS [ Sum p q a b] Source # readPrec :: ReadPrec ( Sum p q a b) Source # readListPrec :: ReadPrec [ Sum p q a b] Source #
( Read (f a b), Read (g a b)) => Read ( Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods readsPrec :: Int -> ReadS ( Product f g a b) Source # readList :: ReadS [ Product f g a b] Source # readPrec :: ReadPrec ( Product f g a b) Source # readListPrec :: ReadPrec [ Product f g a b] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g) Source # readList :: ReadS [(a, b, c, d, e, f, g)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g)] Source #
Read (f (p a b)) => Read ( Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods readsPrec :: Int -> ReadS ( Tannen f p a b) Source # readList :: ReadS [ Tannen f p a b] Source # readPrec :: ReadPrec ( Tannen f p a b) Source # readListPrec :: ReadPrec [ Tannen f p a b] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h) Source # readList :: ReadS [(a, b, c, d, e, f, g, h)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i) Source # readList :: ReadS [(a, b, c, d, e, f, g, h, i)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)] Source #
Read (p (f a) (g b)) => Read ( Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods readsPrec :: Int -> ReadS ( Biff p f g a b) Source # readList :: ReadS [ Biff p f g a b] Source # readPrec :: ReadPrec ( Biff p f g a b) Source # readListPrec :: ReadPrec [ Biff p f g a b] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j) Source # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k) Source # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l) Source # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] Source #
( Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source #

class ( Num a, Ord a) => Real a where Source #

Methods

toRational :: a -> Rational Source #

the rational equivalent of its real argument with full precision

Instances

Instances details

Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational Source #
Real Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int8 -> Rational Source #
Real Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int16 -> Rational Source #
Real Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int32 -> Rational Source #
Real Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int64 -> Rational Source #
Real Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Integer -> Rational Source #
Real Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational Source #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational Source #
Real Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word8 -> Rational Source #
Real Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word16 -> Rational Source #
Real Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word32 -> Rational Source #
Real Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word64 -> Rational Source #
Real Scientific	WARNING: `toRational` needs to compute the `Integer` magnitude: `10^e` . If applied to a huge exponent this could fill up all space and crash your program! Avoid applying `toRational` (or `realToFrac` ) to scientific numbers coming from an untrusted source and use `toRealFloat` instead. The latter guards against excessive space usage.
Instance details Defined in Data.Scientific Methods toRational :: Scientific -> Rational Source #
Real CDev
Instance details Defined in System.Posix.Types Methods toRational :: CDev -> Rational Source #
Real CIno
Instance details Defined in System.Posix.Types Methods toRational :: CIno -> Rational Source #
Real CMode
Instance details Defined in System.Posix.Types Methods toRational :: CMode -> Rational Source #
Real COff
Instance details Defined in System.Posix.Types Methods toRational :: COff -> Rational Source #
Real CPid
Instance details Defined in System.Posix.Types Methods toRational :: CPid -> Rational Source #
Real CSsize
Instance details Defined in System.Posix.Types Methods toRational :: CSsize -> Rational Source #
Real CGid
Instance details Defined in System.Posix.Types Methods toRational :: CGid -> Rational Source #
Real CNlink
Instance details Defined in System.Posix.Types Methods toRational :: CNlink -> Rational Source #
Real CUid
Instance details Defined in System.Posix.Types Methods toRational :: CUid -> Rational Source #
Real CCc
Instance details Defined in System.Posix.Types Methods toRational :: CCc -> Rational Source #
Real CSpeed
Instance details Defined in System.Posix.Types Methods toRational :: CSpeed -> Rational Source #
Real CTcflag
Instance details Defined in System.Posix.Types Methods toRational :: CTcflag -> Rational Source #
Real CRLim
Instance details Defined in System.Posix.Types Methods toRational :: CRLim -> Rational Source #
Real CBlkSize
Instance details Defined in System.Posix.Types Methods toRational :: CBlkSize -> Rational Source #
Real CBlkCnt
Instance details Defined in System.Posix.Types Methods toRational :: CBlkCnt -> Rational Source #
Real CClockId
Instance details Defined in System.Posix.Types Methods toRational :: CClockId -> Rational Source #
Real CFsBlkCnt
Instance details Defined in System.Posix.Types Methods toRational :: CFsBlkCnt -> Rational Source #
Real CFsFilCnt
Instance details Defined in System.Posix.Types Methods toRational :: CFsFilCnt -> Rational Source #
Real CId
Instance details Defined in System.Posix.Types Methods toRational :: CId -> Rational Source #
Real CKey
Instance details Defined in System.Posix.Types Methods toRational :: CKey -> Rational Source #
Real CSocklen
Instance details Defined in System.Posix.Types Methods toRational :: CSocklen -> Rational Source #
Real CNfds
Instance details Defined in System.Posix.Types Methods toRational :: CNfds -> Rational Source #
Real Fd
Instance details Defined in System.Posix.Types Methods toRational :: Fd -> Rational Source #
Real CChar
Instance details Defined in Foreign.C.Types Methods toRational :: CChar -> Rational Source #
Real CSChar
Instance details Defined in Foreign.C.Types Methods toRational :: CSChar -> Rational Source #
Real CUChar
Instance details Defined in Foreign.C.Types Methods toRational :: CUChar -> Rational Source #
Real CShort
Instance details Defined in Foreign.C.Types Methods toRational :: CShort -> Rational Source #
Real CUShort
Instance details Defined in Foreign.C.Types Methods toRational :: CUShort -> Rational Source #
Real CInt
Instance details Defined in Foreign.C.Types Methods toRational :: CInt -> Rational Source #
Real CUInt
Instance details Defined in Foreign.C.Types Methods toRational :: CUInt -> Rational Source #
Real CLong
Instance details Defined in Foreign.C.Types Methods toRational :: CLong -> Rational Source #
Real CULong
Instance details Defined in Foreign.C.Types Methods toRational :: CULong -> Rational Source #
Real CLLong
Instance details Defined in Foreign.C.Types Methods toRational :: CLLong -> Rational Source #
Real CULLong
Instance details Defined in Foreign.C.Types Methods toRational :: CULLong -> Rational Source #
Real CBool
Instance details Defined in Foreign.C.Types Methods toRational :: CBool -> Rational Source #
Real CFloat
Instance details Defined in Foreign.C.Types Methods toRational :: CFloat -> Rational Source #
Real CDouble
Instance details Defined in Foreign.C.Types Methods toRational :: CDouble -> Rational Source #
Real CPtrdiff
Instance details Defined in Foreign.C.Types Methods toRational :: CPtrdiff -> Rational Source #
Real CSize
Instance details Defined in Foreign.C.Types Methods toRational :: CSize -> Rational Source #
Real CWchar
Instance details Defined in Foreign.C.Types Methods toRational :: CWchar -> Rational Source #
Real CSigAtomic
Instance details Defined in Foreign.C.Types Methods toRational :: CSigAtomic -> Rational Source #
Real CClock
Instance details Defined in Foreign.C.Types Methods toRational :: CClock -> Rational Source #
Real CTime
Instance details Defined in Foreign.C.Types Methods toRational :: CTime -> Rational Source #
Real CUSeconds
Instance details Defined in Foreign.C.Types Methods toRational :: CUSeconds -> Rational Source #
Real CSUSeconds
Instance details Defined in Foreign.C.Types Methods toRational :: CSUSeconds -> Rational Source #
Real CIntPtr
Instance details Defined in Foreign.C.Types Methods toRational :: CIntPtr -> Rational Source #
Real CUIntPtr
Instance details Defined in Foreign.C.Types Methods toRational :: CUIntPtr -> Rational Source #
Real CIntMax
Instance details Defined in Foreign.C.Types Methods toRational :: CIntMax -> Rational Source #
Real CUIntMax
Instance details Defined in Foreign.C.Types Methods toRational :: CUIntMax -> Rational Source #
Real WordPtr
Instance details Defined in Foreign.Ptr Methods toRational :: WordPtr -> Rational Source #
Real IntPtr
Instance details Defined in Foreign.Ptr Methods toRational :: IntPtr -> Rational Source #
Real Int54
Instance details Defined in Text.JSON.Canonical.Types Methods toRational :: Int54 -> Rational Source #
Real DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods toRational :: DiffTime -> Rational Source #
Real NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods toRational :: NominalDiffTime -> Rational Source #
Integral a => Real ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Ratio a -> Rational Source #
Real a => Real ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational Source #
Real a => Real ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods toRational :: Down a -> Rational Source #
Real a => Real ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods toRational :: Hex a -> Rational Source #
Real a => Real ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods toRational :: Shown a -> Rational Source #
HasResolution a => Real ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods toRational :: Fixed a -> Rational Source #
Real a => Real ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational Source #
Real a => Real ( Tagged s a)
Instance details Defined in Data.Tagged Methods toRational :: Tagged s a -> Rational Source #

class ( RealFrac a, Floating a) => RealFloat a where Source #

Efficient, machine-independent access to the components of a floating-point number.

Minimal complete definition

floatRadix , floatDigits , floatRange , decodeFloat , encodeFloat , isNaN , isInfinite , isDenormalized , isNegativeZero , isIEEE

Methods

floatRadix :: a -> Integer Source #

a constant function, returning the radix of the representation (often 2 )

floatDigits :: a -> Int Source #

a constant function, returning the number of digits of floatRadix in the significand

floatRange :: a -> ( Int , Int ) Source #

a constant function, returning the lowest and highest values the exponent may assume

decodeFloat :: a -> ( Integer , Int ) Source #

The function decodeFloat applied to a real floating-point number returns the significand expressed as an Integer and an appropriately scaled exponent (an Int ). If decodeFloat x yields (m,n) , then x is equal in value to m*b^^n , where b is the floating-point radix, and furthermore, either m and n are both zero or else b^(d-1) <= abs m < b^d , where d is the value of floatDigits x . In particular, decodeFloat 0 = (0,0) . If the type contains a negative zero, also decodeFloat (-0.0) = (0,0) . The result of decodeFloat x is unspecified if either of isNaN x or isInfinite x is True .

encodeFloat :: Integer -> Int -> a Source #

encodeFloat performs the inverse of decodeFloat in the sense that for finite x with the exception of -0.0 , uncurry encodeFloat ( decodeFloat x) = x . encodeFloat m n is one of the two closest representable floating-point numbers to m*b^^n (or ±Infinity if overflow occurs); usually the closer, but if m contains too many bits, the result may be rounded in the wrong direction.

exponent :: a -> Int Source #

exponent corresponds to the second component of decodeFloat . exponent 0 = 0 and for finite nonzero x , exponent x = snd ( decodeFloat x) + floatDigits x . If x is a finite floating-point number, it is equal in value to significand x * b ^^ exponent x , where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

significand :: a -> a Source #

The first component of decodeFloat , scaled to lie in the open interval ( -1 , 1 ), either 0.0 or of absolute value >= 1/b , where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

scaleFloat :: Int -> a -> a Source #

multiplies a floating-point number by an integer power of the radix

isNaN :: a -> Bool Source #

True if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: a -> Bool Source #

True if the argument is an IEEE infinity or negative infinity

isDenormalized :: a -> Bool Source #

True if the argument is too small to be represented in normalized format

isNegativeZero :: a -> Bool Source #

True if the argument is an IEEE negative zero

isIEEE :: a -> Bool Source #

True if the argument is an IEEE floating point number

atan2 :: a -> a -> a Source #

a version of arctangent taking two real floating-point arguments. For real floating x and y , atan2 y x computes the angle (from the positive x-axis) of the vector from the origin to the point (x,y) . atan2 y x returns a value in the range [ -pi , pi ]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. atan2 y 1 , with y in a type that is RealFloat , should return the same value as atan y . A default definition of atan2 is provided, but implementors can provide a more accurate implementation.

Instances

Instances details

RealFloat Double	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Double -> Integer Source # floatDigits :: Double -> Int Source # floatRange :: Double -> ( Int , Int ) Source # decodeFloat :: Double -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Double Source # exponent :: Double -> Int Source # significand :: Double -> Double Source # scaleFloat :: Int -> Double -> Double Source # isNaN :: Double -> Bool Source # isInfinite :: Double -> Bool Source # isDenormalized :: Double -> Bool Source # isNegativeZero :: Double -> Bool Source # isIEEE :: Double -> Bool Source # atan2 :: Double -> Double -> Double Source #
RealFloat Float	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Float -> Integer Source # floatDigits :: Float -> Int Source # floatRange :: Float -> ( Int , Int ) Source # decodeFloat :: Float -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Float Source # exponent :: Float -> Int Source # significand :: Float -> Float Source # scaleFloat :: Int -> Float -> Float Source # isNaN :: Float -> Bool Source # isInfinite :: Float -> Bool Source # isDenormalized :: Float -> Bool Source # isNegativeZero :: Float -> Bool Source # isIEEE :: Float -> Bool Source # atan2 :: Float -> Float -> Float Source #
RealFloat CFloat
Instance details Defined in Foreign.C.Types Methods floatRadix :: CFloat -> Integer Source # floatDigits :: CFloat -> Int Source # floatRange :: CFloat -> ( Int , Int ) Source # decodeFloat :: CFloat -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> CFloat Source # exponent :: CFloat -> Int Source # significand :: CFloat -> CFloat Source # scaleFloat :: Int -> CFloat -> CFloat Source # isNaN :: CFloat -> Bool Source # isInfinite :: CFloat -> Bool Source # isDenormalized :: CFloat -> Bool Source # isNegativeZero :: CFloat -> Bool Source # isIEEE :: CFloat -> Bool Source # atan2 :: CFloat -> CFloat -> CFloat Source #
RealFloat CDouble
Instance details Defined in Foreign.C.Types Methods floatRadix :: CDouble -> Integer Source # floatDigits :: CDouble -> Int Source # floatRange :: CDouble -> ( Int , Int ) Source # decodeFloat :: CDouble -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> CDouble Source # exponent :: CDouble -> Int Source # significand :: CDouble -> CDouble Source # scaleFloat :: Int -> CDouble -> CDouble Source # isNaN :: CDouble -> Bool Source # isInfinite :: CDouble -> Bool Source # isDenormalized :: CDouble -> Bool Source # isNegativeZero :: CDouble -> Bool Source # isIEEE :: CDouble -> Bool Source # atan2 :: CDouble -> CDouble -> CDouble Source #
RealFloat a => RealFloat ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer Source # floatDigits :: Identity a -> Int Source # floatRange :: Identity a -> ( Int , Int ) Source # decodeFloat :: Identity a -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Identity a Source # exponent :: Identity a -> Int Source # significand :: Identity a -> Identity a Source # scaleFloat :: Int -> Identity a -> Identity a Source # isNaN :: Identity a -> Bool Source # isInfinite :: Identity a -> Bool Source # isDenormalized :: Identity a -> Bool Source # isNegativeZero :: Identity a -> Bool Source # isIEEE :: Identity a -> Bool Source # atan2 :: Identity a -> Identity a -> Identity a Source #
RealFloat a => RealFloat ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods floatRadix :: Down a -> Integer Source # floatDigits :: Down a -> Int Source # floatRange :: Down a -> ( Int , Int ) Source # decodeFloat :: Down a -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Down a Source # exponent :: Down a -> Int Source # significand :: Down a -> Down a Source # scaleFloat :: Int -> Down a -> Down a Source # isNaN :: Down a -> Bool Source # isInfinite :: Down a -> Bool Source # isDenormalized :: Down a -> Bool Source # isNegativeZero :: Down a -> Bool Source # isIEEE :: Down a -> Bool Source # atan2 :: Down a -> Down a -> Down a Source #
RealFloat a => RealFloat ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods floatRadix :: Shown a -> Integer Source # floatDigits :: Shown a -> Int Source # floatRange :: Shown a -> ( Int , Int ) Source # decodeFloat :: Shown a -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Shown a Source # exponent :: Shown a -> Int Source # significand :: Shown a -> Shown a Source # scaleFloat :: Int -> Shown a -> Shown a Source # isNaN :: Shown a -> Bool Source # isInfinite :: Shown a -> Bool Source # isDenormalized :: Shown a -> Bool Source # isNegativeZero :: Shown a -> Bool Source # isIEEE :: Shown a -> Bool Source # atan2 :: Shown a -> Shown a -> Shown a Source #
RealFloat a => RealFloat ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer Source # floatDigits :: Const a b -> Int Source # floatRange :: Const a b -> ( Int , Int ) Source # decodeFloat :: Const a b -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Const a b Source # exponent :: Const a b -> Int Source # significand :: Const a b -> Const a b Source # scaleFloat :: Int -> Const a b -> Const a b Source # isNaN :: Const a b -> Bool Source # isInfinite :: Const a b -> Bool Source # isDenormalized :: Const a b -> Bool Source # isNegativeZero :: Const a b -> Bool Source # isIEEE :: Const a b -> Bool Source # atan2 :: Const a b -> Const a b -> Const a b Source #
RealFloat a => RealFloat ( Tagged s a)
Instance details Defined in Data.Tagged Methods floatRadix :: Tagged s a -> Integer Source # floatDigits :: Tagged s a -> Int Source # floatRange :: Tagged s a -> ( Int , Int ) Source # decodeFloat :: Tagged s a -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Tagged s a Source # exponent :: Tagged s a -> Int Source # significand :: Tagged s a -> Tagged s a Source # scaleFloat :: Int -> Tagged s a -> Tagged s a Source # isNaN :: Tagged s a -> Bool Source # isInfinite :: Tagged s a -> Bool Source # isDenormalized :: Tagged s a -> Bool Source # isNegativeZero :: Tagged s a -> Bool Source # isIEEE :: Tagged s a -> Bool Source # atan2 :: Tagged s a -> Tagged s a -> Tagged s a Source #

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

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

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

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

truncate x returns the integer nearest x between zero and x

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

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

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

ceiling x returns the least integer not less than x

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

floor x returns the greatest integer not greater than x

Instances

Instances details

RealFrac Scientific	WARNING: the methods of the `RealFrac` instance need to compute the magnitude `10^e` . If applied to a huge exponent this could take a long time. Even worse, when the destination type is unbounded (i.e. `Integer` ) it could fill up all space and crash your program!
Instance details Defined in Data.Scientific Methods properFraction :: Integral b => Scientific -> (b, Scientific ) Source # truncate :: Integral b => Scientific -> b Source # round :: Integral b => Scientific -> b Source # ceiling :: Integral b => Scientific -> b Source # floor :: Integral b => Scientific -> b Source #
RealFrac CFloat
Instance details Defined in Foreign.C.Types Methods properFraction :: Integral b => CFloat -> (b, CFloat ) Source # truncate :: Integral b => CFloat -> b Source # round :: Integral b => CFloat -> b Source # ceiling :: Integral b => CFloat -> b Source # floor :: Integral b => CFloat -> b Source #
RealFrac CDouble
Instance details Defined in Foreign.C.Types Methods properFraction :: Integral b => CDouble -> (b, CDouble ) Source # truncate :: Integral b => CDouble -> b Source # round :: Integral b => CDouble -> b Source # ceiling :: Integral b => CDouble -> b Source # floor :: Integral b => CDouble -> b Source #
RealFrac DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods properFraction :: Integral b => DiffTime -> (b, DiffTime ) Source # truncate :: Integral b => DiffTime -> b Source # round :: Integral b => DiffTime -> b Source # ceiling :: Integral b => DiffTime -> b Source # floor :: Integral b => DiffTime -> b Source #
RealFrac NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods properFraction :: Integral b => NominalDiffTime -> (b, NominalDiffTime ) Source # truncate :: Integral b => NominalDiffTime -> b Source # round :: Integral b => NominalDiffTime -> b Source # ceiling :: Integral b => NominalDiffTime -> b Source # floor :: Integral b => NominalDiffTime -> b Source #
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) Source # truncate :: Integral b => Ratio a -> b Source # round :: Integral b => Ratio a -> b Source # ceiling :: Integral b => Ratio a -> b Source # floor :: Integral b => Ratio a -> b Source #
RealFrac a => RealFrac ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) Source # truncate :: Integral b => Identity a -> b Source # round :: Integral b => Identity a -> b Source # ceiling :: Integral b => Identity a -> b Source # floor :: Integral b => Identity a -> b Source #
RealFrac a => RealFrac ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods properFraction :: Integral b => Down a -> (b, Down a) Source # truncate :: Integral b => Down a -> b Source # round :: Integral b => Down a -> b Source # ceiling :: Integral b => Down a -> b Source # floor :: Integral b => Down a -> b Source #
RealFrac a => RealFrac ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods properFraction :: Integral b => Shown a -> (b, Shown a) Source # truncate :: Integral b => Shown a -> b Source # round :: Integral b => Shown a -> b Source # ceiling :: Integral b => Shown a -> b Source # floor :: Integral b => Shown a -> b Source #
HasResolution a => RealFrac ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods properFraction :: Integral b => Fixed a -> (b, Fixed a) Source # truncate :: Integral b => Fixed a -> b Source # round :: Integral b => Fixed a -> b Source # ceiling :: Integral b => Fixed a -> b Source # floor :: Integral b => Fixed a -> b Source #
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) Source # truncate :: Integral b0 => Const a b -> b0 Source # round :: Integral b0 => Const a b -> b0 Source # ceiling :: Integral b0 => Const a b -> b0 Source # floor :: Integral b0 => Const a b -> b0 Source #
RealFrac a => RealFrac ( Tagged s a)
Instance details Defined in Data.Tagged Methods properFraction :: Integral b => Tagged s a -> (b, Tagged s a) Source # truncate :: Integral b => Tagged s a -> b Source # round :: Integral b => Tagged s a -> b Source # ceiling :: Integral b => Tagged s a -> b Source # floor :: Integral b => Tagged s a -> b Source #

class Show a Source #

Conversion of values to readable String s.

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

Instances

Instances details

Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS Source # show :: Bool -> String Source # showList :: [ Bool ] -> ShowS Source #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS Source # show :: Char -> String Source # showList :: [ Char ] -> ShowS Source #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS Source # show :: Int -> String Source # showList :: [ Int ] -> ShowS Source #
Show Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int8 -> ShowS Source # show :: Int8 -> String Source # showList :: [ Int8 ] -> ShowS Source #
Show Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int16 -> ShowS Source # show :: Int16 -> String Source # showList :: [ Int16 ] -> ShowS Source #
Show Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int32 -> ShowS Source # show :: Int32 -> String Source # showList :: [ Int32 ] -> ShowS Source #
Show Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int64 -> ShowS Source # show :: Int64 -> String Source # showList :: [ Int64 ] -> ShowS Source #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS Source # show :: Integer -> String Source # showList :: [ Integer ] -> ShowS Source #
Show Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS Source # show :: Natural -> String Source # showList :: [ Natural ] -> ShowS Source #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS Source # show :: Ordering -> String Source # showList :: [ Ordering ] -> ShowS Source #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS Source # show :: Word -> String Source # showList :: [ Word ] -> ShowS Source #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS Source # show :: Word8 -> String Source # showList :: [ Word8 ] -> ShowS Source #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS Source # show :: Word16 -> String Source # showList :: [ Word16 ] -> ShowS Source #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS Source # show :: Word32 -> String Source # showList :: [ Word32 ] -> ShowS Source #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS Source # show :: Word64 -> String Source # showList :: [ Word64 ] -> ShowS Source #
Show RuntimeRep	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> RuntimeRep -> ShowS Source # show :: RuntimeRep -> String Source # showList :: [ RuntimeRep ] -> ShowS Source #
Show VecCount	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecCount -> ShowS Source # show :: VecCount -> String Source # showList :: [ VecCount ] -> ShowS Source #
Show VecElem	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecElem -> ShowS Source # show :: VecElem -> String Source # showList :: [ VecElem ] -> ShowS Source #
Show CallStack	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> CallStack -> ShowS Source # show :: CallStack -> String Source # showList :: [ CallStack ] -> ShowS Source #
Show SomeTypeRep	Since: base-4.10.0.0
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> SomeTypeRep -> ShowS Source # show :: SomeTypeRep -> String Source # showList :: [ SomeTypeRep ] -> ShowS Source #
Show Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Exp -> ShowS Source # show :: Exp -> String Source # showList :: [ Exp ] -> ShowS Source #
Show Match
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Match -> ShowS Source # show :: Match -> String Source # showList :: [ Match ] -> ShowS Source #
Show Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Clause -> ShowS Source # show :: Clause -> String Source # showList :: [ Clause ] -> ShowS Source #
Show Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pat -> ShowS Source # show :: Pat -> String Source # showList :: [ Pat ] -> ShowS Source #
Show Type
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Type -> ShowS Source # show :: Type -> String Source # showList :: [ Type ] -> ShowS Source #
Show Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Dec -> ShowS Source # show :: Dec -> String Source # showList :: [ Dec ] -> ShowS Source #
Show Name
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Name -> ShowS Source # show :: Name -> String Source # showList :: [ Name ] -> ShowS Source #
Show FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FunDep -> ShowS Source # show :: FunDep -> String Source # showList :: [ FunDep ] -> ShowS Source #
Show InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> InjectivityAnn -> ShowS Source # show :: InjectivityAnn -> String Source # showList :: [ InjectivityAnn ] -> ShowS Source #
Show Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Overlap -> ShowS Source # show :: Overlap -> String Source # showList :: [ Overlap ] -> ShowS Source #
Show ()	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> () -> ShowS Source # show :: () -> String Source # showList :: [()] -> ShowS Source #
Show TyCon	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TyCon -> ShowS Source # show :: TyCon -> String Source # showList :: [ TyCon ] -> ShowS Source #
Show Module	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Module -> ShowS Source # show :: Module -> String Source # showList :: [ Module ] -> ShowS Source #
Show TrName	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TrName -> ShowS Source # show :: TrName -> String Source # showList :: [ TrName ] -> ShowS Source #
Show KindRep
Instance details Defined in GHC.Show Methods showsPrec :: Int -> KindRep -> ShowS Source # show :: KindRep -> String Source # showList :: [ KindRep ] -> ShowS Source #
Show TypeLitSort	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TypeLitSort -> ShowS Source # show :: TypeLitSort -> String Source # showList :: [ TypeLitSort ] -> ShowS Source #
Show ByteString
Instance details Defined in Data.ByteString.Internal Methods showsPrec :: Int -> ByteString -> ShowS Source # show :: ByteString -> String Source # showList :: [ ByteString ] -> ShowS Source #
Show ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods showsPrec :: Int -> ByteString -> ShowS Source # show :: ByteString -> String Source # showList :: [ ByteString ] -> ShowS Source #
Show Builder
Instance details Defined in Data.Text.Internal.Builder Methods showsPrec :: Int -> Builder -> ShowS Source # show :: Builder -> String Source # showList :: [ Builder ] -> ShowS Source #
Show Scientific	See `formatScientific` if you need more control over the rendering.
Instance details Defined in Data.Scientific Methods showsPrec :: Int -> Scientific -> ShowS Source # show :: Scientific -> String Source # showList :: [ Scientific ] -> ShowS Source #
Show JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> JSONPathElement -> ShowS Source # show :: JSONPathElement -> String Source # showList :: [ JSONPathElement ] -> ShowS Source #
Show Value	Since version 1.5.6.0 version object values are printed in lexicographic key order `>>>` `toJSON $ H.fromList [("a", True), ("z", False)]`Object (fromList [("a",Bool True),("z",Bool False)]) `>>>` `toJSON $ H.fromList [("z", False), ("a", True)]`Object (fromList [("a",Bool True),("z",Bool False)])
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Value -> ShowS Source # show :: Value -> String Source # showList :: [ Value ] -> ShowS Source #
Show DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> DotNetTime -> ShowS Source # show :: DotNetTime -> String Source # showList :: [ DotNetTime ] -> ShowS Source #
Show Options
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Options -> ShowS Source # show :: Options -> String Source # showList :: [ Options ] -> ShowS Source #
Show SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> SumEncoding -> ShowS Source # show :: SumEncoding -> String Source # showList :: [ SumEncoding ] -> ShowS Source #
Show Key
Instance details Defined in Data.Aeson.Key Methods showsPrec :: Int -> Key -> ShowS Source # show :: Key -> String Source # showList :: [ Key ] -> ShowS Source #
Show Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS Source # show :: Handle -> String Source # showList :: [ Handle ] -> ShowS Source #
Show ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> ThreadId -> ShowS Source # show :: ThreadId -> String Source # showList :: [ ThreadId ] -> ShowS Source #
Show AsyncCancelled
Instance details Defined in Control.Concurrent.Async Methods showsPrec :: Int -> AsyncCancelled -> ShowS Source # show :: AsyncCancelled -> String Source # showList :: [ AsyncCancelled ] -> ShowS Source #
Show ExceptionInLinkedThread
Instance details Defined in Control.Concurrent.Async Methods showsPrec :: Int -> ExceptionInLinkedThread -> ShowS Source # show :: ExceptionInLinkedThread -> String Source # showList :: [ ExceptionInLinkedThread ] -> ShowS Source #
Show Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods showsPrec :: Int -> Pos -> ShowS Source # show :: Pos -> String Source # showList :: [ Pos ] -> ShowS Source #
Show More
Instance details Defined in Data.Attoparsec.Internal.Types Methods showsPrec :: Int -> More -> ShowS Source # show :: More -> String Source # showList :: [ More ] -> ShowS Source #
Show Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods showsPrec :: Int -> Void -> ShowS Source # show :: Void -> String Source # showList :: [ Void ] -> ShowS Source #
Show StaticPtrInfo	Since: base-4.8.0.0
Instance details Defined in GHC.StaticPtr Methods showsPrec :: Int -> StaticPtrInfo -> ShowS Source # show :: StaticPtrInfo -> String Source # showList :: [ StaticPtrInfo ] -> ShowS Source #
Show Version	Since: base-2.1
Instance details Defined in Data.Version Methods showsPrec :: Int -> Version -> ShowS Source # show :: Version -> String Source # showList :: [ Version ] -> ShowS Source #
Show PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> PatternMatchFail -> ShowS Source # show :: PatternMatchFail -> String Source # showList :: [ PatternMatchFail ] -> ShowS Source #
Show RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecSelError -> ShowS Source # show :: RecSelError -> String Source # showList :: [ RecSelError ] -> ShowS Source #
Show RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecConError -> ShowS Source # show :: RecConError -> String Source # showList :: [ RecConError ] -> ShowS Source #
Show RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecUpdError -> ShowS Source # show :: RecUpdError -> String Source # showList :: [ RecUpdError ] -> ShowS Source #
Show NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NoMethodError -> ShowS Source # show :: NoMethodError -> String Source # showList :: [ NoMethodError ] -> ShowS Source #
Show TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> TypeError -> ShowS Source # show :: TypeError -> String Source # showList :: [ TypeError ] -> ShowS Source #
Show NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NonTermination -> ShowS Source # show :: NonTermination -> String Source # showList :: [ NonTermination ] -> ShowS Source #
Show NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NestedAtomically -> ShowS Source # show :: NestedAtomically -> String Source # showList :: [ NestedAtomically ] -> ShowS Source #
Show BlockReason	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> BlockReason -> ShowS Source # show :: BlockReason -> String Source # showList :: [ BlockReason ] -> ShowS Source #
Show ThreadStatus	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> ThreadStatus -> ShowS Source # show :: ThreadStatus -> String Source # showList :: [ ThreadStatus ] -> ShowS Source #
Show CDev
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CDev -> ShowS Source # show :: CDev -> String Source # showList :: [ CDev ] -> ShowS Source #
Show CIno
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CIno -> ShowS Source # show :: CIno -> String Source # showList :: [ CIno ] -> ShowS Source #
Show CMode
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CMode -> ShowS Source # show :: CMode -> String Source # showList :: [ CMode ] -> ShowS Source #
Show COff
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> COff -> ShowS Source # show :: COff -> String Source # showList :: [ COff ] -> ShowS Source #
Show CPid
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CPid -> ShowS Source # show :: CPid -> String Source # showList :: [ CPid ] -> ShowS Source #
Show CSsize
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CSsize -> ShowS Source # show :: CSsize -> String Source # showList :: [ CSsize ] -> ShowS Source #
Show CGid
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CGid -> ShowS Source # show :: CGid -> String Source # showList :: [ CGid ] -> ShowS Source #
Show CNlink
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CNlink -> ShowS Source # show :: CNlink -> String Source # showList :: [ CNlink ] -> ShowS Source #
Show CUid
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CUid -> ShowS Source # show :: CUid -> String Source # showList :: [ CUid ] -> ShowS Source #
Show CCc
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CCc -> ShowS Source # show :: CCc -> String Source # showList :: [ CCc ] -> ShowS Source #
Show CSpeed
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CSpeed -> ShowS Source # show :: CSpeed -> String Source # showList :: [ CSpeed ] -> ShowS Source #
Show CTcflag
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CTcflag -> ShowS Source # show :: CTcflag -> String Source # showList :: [ CTcflag ] -> ShowS Source #
Show CRLim
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CRLim -> ShowS Source # show :: CRLim -> String Source # showList :: [ CRLim ] -> ShowS Source #
Show CBlkSize
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CBlkSize -> ShowS Source # show :: CBlkSize -> String Source # showList :: [ CBlkSize ] -> ShowS Source #
Show CBlkCnt
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CBlkCnt -> ShowS Source # show :: CBlkCnt -> String Source # showList :: [ CBlkCnt ] -> ShowS Source #
Show CClockId
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CClockId -> ShowS Source # show :: CClockId -> String Source # showList :: [ CClockId ] -> ShowS Source #
Show CFsBlkCnt
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CFsBlkCnt -> ShowS Source # show :: CFsBlkCnt -> String Source # showList :: [ CFsBlkCnt ] -> ShowS Source #
Show CFsFilCnt
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CFsFilCnt -> ShowS Source # show :: CFsFilCnt -> String Source # showList :: [ CFsFilCnt ] -> ShowS Source #
Show CId
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CId -> ShowS Source # show :: CId -> String Source # showList :: [ CId ] -> ShowS Source #
Show CKey
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CKey -> ShowS Source # show :: CKey -> String Source # showList :: [ CKey ] -> ShowS Source #
Show CSocklen
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CSocklen -> ShowS Source # show :: CSocklen -> String Source # showList :: [ CSocklen ] -> ShowS Source #
Show CNfds
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> CNfds -> ShowS Source # show :: CNfds -> String Source # showList :: [ CNfds ] -> ShowS Source #
Show Fd
Instance details Defined in System.Posix.Types Methods showsPrec :: Int -> Fd -> ShowS Source # show :: Fd -> String Source # showList :: [ Fd ] -> ShowS Source #
Show BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS Source # show :: BlockedIndefinitelyOnMVar -> String Source # showList :: [ BlockedIndefinitelyOnMVar ] -> ShowS Source #
Show BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS Source # show :: BlockedIndefinitelyOnSTM -> String Source # showList :: [ BlockedIndefinitelyOnSTM ] -> ShowS Source #
Show Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> Deadlock -> ShowS Source # show :: Deadlock -> String Source # showList :: [ Deadlock ] -> ShowS Source #
Show AllocationLimitExceeded	Since: base-4.7.1.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS Source # show :: AllocationLimitExceeded -> String Source # showList :: [ AllocationLimitExceeded ] -> ShowS Source #
Show CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> CompactionFailed -> ShowS Source # show :: CompactionFailed -> String Source # showList :: [ CompactionFailed ] -> ShowS Source #
Show AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AssertionFailed -> ShowS Source # show :: AssertionFailed -> String Source # showList :: [ AssertionFailed ] -> ShowS Source #
Show SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> SomeAsyncException -> ShowS Source # show :: SomeAsyncException -> String Source # showList :: [ SomeAsyncException ] -> ShowS Source #
Show AsyncException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AsyncException -> ShowS Source # show :: AsyncException -> String Source # showList :: [ AsyncException ] -> ShowS Source #
Show ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ArrayException -> ShowS Source # show :: ArrayException -> String Source # showList :: [ ArrayException ] -> ShowS Source #
Show FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> FixIOException -> ShowS Source # show :: FixIOException -> String Source # showList :: [ FixIOException ] -> ShowS Source #
Show ExitCode
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ExitCode -> ShowS Source # show :: ExitCode -> String Source # showList :: [ ExitCode ] -> ShowS Source #
Show IOErrorType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOErrorType -> ShowS Source # show :: IOErrorType -> String Source # showList :: [ IOErrorType ] -> ShowS Source #
Show HandleType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> HandleType -> ShowS Source # show :: HandleType -> String Source # showList :: [ HandleType ] -> ShowS Source #
Show BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> BufferMode -> ShowS Source # show :: BufferMode -> String Source # showList :: [ BufferMode ] -> ShowS Source #
Show Newline	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Newline -> ShowS Source # show :: Newline -> String Source # showList :: [ Newline ] -> ShowS Source #
Show NewlineMode	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> NewlineMode -> ShowS Source # show :: NewlineMode -> String Source # showList :: [ NewlineMode ] -> ShowS Source #
Show MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods showsPrec :: Int -> MaskingState -> ShowS Source # show :: MaskingState -> String Source # showList :: [ MaskingState ] -> ShowS Source #
Show IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOException -> ShowS Source # show :: IOException -> String Source # showList :: [ IOException ] -> ShowS Source #
Show ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods showsPrec :: Int -> ErrorCall -> ShowS Source # show :: ErrorCall -> String Source # showList :: [ ErrorCall ] -> ShowS Source #
Show ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS Source # show :: ArithException -> String Source # showList :: [ ArithException ] -> ShowS Source #
Show All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> All -> ShowS Source # show :: All -> String Source # showList :: [ All ] -> ShowS Source #
Show Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Any -> ShowS Source # show :: Any -> String Source # showList :: [ Any ] -> ShowS Source #
Show Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Fixity -> ShowS Source # show :: Fixity -> String Source # showList :: [ Fixity ] -> ShowS Source #
Show Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Associativity -> ShowS Source # show :: Associativity -> String Source # showList :: [ Associativity ] -> ShowS Source #
Show SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceUnpackedness -> ShowS Source # show :: SourceUnpackedness -> String Source # showList :: [ SourceUnpackedness ] -> ShowS Source #
Show SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceStrictness -> ShowS Source # show :: SourceStrictness -> String Source # showList :: [ SourceStrictness ] -> ShowS Source #
Show DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> DecidedStrictness -> ShowS Source # show :: DecidedStrictness -> String Source # showList :: [ DecidedStrictness ] -> ShowS Source #
Show SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods showsPrec :: Int -> SomeSymbol -> ShowS Source # show :: SomeSymbol -> String Source # showList :: [ SomeSymbol ] -> ShowS Source #
Show SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SomeNat -> ShowS Source # show :: SomeNat -> String Source # showList :: [ SomeNat ] -> ShowS Source #
Show CChar
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CChar -> ShowS Source # show :: CChar -> String Source # showList :: [ CChar ] -> ShowS Source #
Show CSChar
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CSChar -> ShowS Source # show :: CSChar -> String Source # showList :: [ CSChar ] -> ShowS Source #
Show CUChar
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUChar -> ShowS Source # show :: CUChar -> String Source # showList :: [ CUChar ] -> ShowS Source #
Show CShort
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CShort -> ShowS Source # show :: CShort -> String Source # showList :: [ CShort ] -> ShowS Source #
Show CUShort
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUShort -> ShowS Source # show :: CUShort -> String Source # showList :: [ CUShort ] -> ShowS Source #
Show CInt
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CInt -> ShowS Source # show :: CInt -> String Source # showList :: [ CInt ] -> ShowS Source #
Show CUInt
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUInt -> ShowS Source # show :: CUInt -> String Source # showList :: [ CUInt ] -> ShowS Source #
Show CLong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CLong -> ShowS Source # show :: CLong -> String Source # showList :: [ CLong ] -> ShowS Source #
Show CULong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CULong -> ShowS Source # show :: CULong -> String Source # showList :: [ CULong ] -> ShowS Source #
Show CLLong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CLLong -> ShowS Source # show :: CLLong -> String Source # showList :: [ CLLong ] -> ShowS Source #
Show CULLong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CULLong -> ShowS Source # show :: CULLong -> String Source # showList :: [ CULLong ] -> ShowS Source #
Show CBool
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CBool -> ShowS Source # show :: CBool -> String Source # showList :: [ CBool ] -> ShowS Source #
Show CFloat
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CFloat -> ShowS Source # show :: CFloat -> String Source # showList :: [ CFloat ] -> ShowS Source #
Show CDouble
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CDouble -> ShowS Source # show :: CDouble -> String Source # showList :: [ CDouble ] -> ShowS Source #
Show CPtrdiff
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CPtrdiff -> ShowS Source # show :: CPtrdiff -> String Source # showList :: [ CPtrdiff ] -> ShowS Source #
Show CSize
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CSize -> ShowS Source # show :: CSize -> String Source # showList :: [ CSize ] -> ShowS Source #
Show CWchar
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CWchar -> ShowS Source # show :: CWchar -> String Source # showList :: [ CWchar ] -> ShowS Source #
Show CSigAtomic
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CSigAtomic -> ShowS Source # show :: CSigAtomic -> String Source # showList :: [ CSigAtomic ] -> ShowS Source #
Show CClock
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CClock -> ShowS Source # show :: CClock -> String Source # showList :: [ CClock ] -> ShowS Source #
Show CTime
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CTime -> ShowS Source # show :: CTime -> String Source # showList :: [ CTime ] -> ShowS Source #
Show CUSeconds
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUSeconds -> ShowS Source # show :: CUSeconds -> String Source # showList :: [ CUSeconds ] -> ShowS Source #
Show CSUSeconds
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CSUSeconds -> ShowS Source # show :: CSUSeconds -> String Source # showList :: [ CSUSeconds ] -> ShowS Source #
Show CIntPtr
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CIntPtr -> ShowS Source # show :: CIntPtr -> String Source # showList :: [ CIntPtr ] -> ShowS Source #
Show CUIntPtr
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUIntPtr -> ShowS Source # show :: CUIntPtr -> String Source # showList :: [ CUIntPtr ] -> ShowS Source #
Show CIntMax
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CIntMax -> ShowS Source # show :: CIntMax -> String Source # showList :: [ CIntMax ] -> ShowS Source #
Show CUIntMax
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUIntMax -> ShowS Source # show :: CUIntMax -> String Source # showList :: [ CUIntMax ] -> ShowS Source #
Show WordPtr
Instance details Defined in Foreign.Ptr Methods showsPrec :: Int -> WordPtr -> ShowS Source # show :: WordPtr -> String Source # showList :: [ WordPtr ] -> ShowS Source #
Show IntPtr
Instance details Defined in Foreign.Ptr Methods showsPrec :: Int -> IntPtr -> ShowS Source # show :: IntPtr -> String Source # showList :: [ IntPtr ] -> ShowS Source #
Show IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods showsPrec :: Int -> IOMode -> ShowS Source # show :: IOMode -> String Source # showList :: [ IOMode ] -> ShowS Source #
Show GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods showsPrec :: Int -> GeneralCategory -> ShowS Source # show :: GeneralCategory -> String Source # showList :: [ GeneralCategory ] -> ShowS Source #
Show SrcLoc	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> SrcLoc -> ShowS Source # show :: SrcLoc -> String Source # showList :: [ SrcLoc ] -> ShowS Source #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS Source # show :: SomeException -> String Source # showList :: [ SomeException ] -> ShowS Source #
Show ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods showsPrec :: Int -> ShortByteString -> ShowS Source # show :: ShortByteString -> String Source # showList :: [ ShortByteString ] -> ShowS Source #
Show JSValue
Instance details Defined in Text.JSON.Canonical.Types Methods showsPrec :: Int -> JSValue -> ShowS Source # show :: JSValue -> String Source # showList :: [ JSValue ] -> ShowS Source #
Show JSString
Instance details Defined in Text.JSON.Canonical.Types Methods showsPrec :: Int -> JSString -> ShowS Source # show :: JSString -> String Source # showList :: [ JSString ] -> ShowS Source #
Show Int54
Instance details Defined in Text.JSON.Canonical.Types Methods showsPrec :: Int -> Int54 -> ShowS Source # show :: Int54 -> String Source # showList :: [ Int54 ] -> ShowS Source #
Show ByteArray	Behavior changed in 0.7.2.0. Before 0.7.2.0, this instance rendered 8-bit words less than 16 as a single hexadecimal digit (e.g. 13 was `0xD` ). Starting with 0.7.2.0, all 8-bit words are represented as two digits (e.g. 13 is `0x0D` ). Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.ByteArray Methods showsPrec :: Int -> ByteArray -> ShowS Source # show :: ByteArray -> String Source # showList :: [ ByteArray ] -> ShowS Source #
Show TokenType
Instance details Defined in Codec.CBOR.Decoding Methods showsPrec :: Int -> TokenType -> ShowS Source # show :: TokenType -> String Source # showList :: [ TokenType ] -> ShowS Source #
Show ByteArray
Instance details Defined in Codec.CBOR.ByteArray Methods showsPrec :: Int -> ByteArray -> ShowS Source # show :: ByteArray -> String Source # showList :: [ ByteArray ] -> ShowS Source #
Show SlicedByteArray
Instance details Defined in Codec.CBOR.ByteArray.Sliced Methods showsPrec :: Int -> SlicedByteArray -> ShowS Source # show :: SlicedByteArray -> String Source # showList :: [ SlicedByteArray ] -> ShowS Source #
Show IntSet
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> IntSet -> ShowS Source # show :: IntSet -> String Source # showList :: [ IntSet ] -> ShowS Source #
Show DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods showsPrec :: Int -> DiffTime -> ShowS Source # show :: DiffTime -> String Source # showList :: [ DiffTime ] -> ShowS Source #
Show NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods showsPrec :: Int -> NominalDiffTime -> ShowS Source # show :: NominalDiffTime -> String Source # showList :: [ NominalDiffTime ] -> ShowS Source #
Show Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods showsPrec :: Int -> Extension -> ShowS Source # show :: Extension -> String Source # showList :: [ Extension ] -> ShowS Source #
Show ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods showsPrec :: Int -> ForeignSrcLang -> ShowS Source # show :: ForeignSrcLang -> String Source # showList :: [ ForeignSrcLang ] -> ShowS Source #
Show Box
Instance details Defined in GHC.Exts.Heap.Closures Methods showsPrec :: Int -> Box -> ShowS Source # show :: Box -> String Source # showList :: [ Box ] -> ShowS Source #
Show PrimType
Instance details Defined in GHC.Exts.Heap.Closures Methods showsPrec :: Int -> PrimType -> ShowS Source # show :: PrimType -> String Source # showList :: [ PrimType ] -> ShowS Source #
Show StgInfoTable
Instance details Defined in GHC.Exts.Heap.InfoTable.Types Methods showsPrec :: Int -> StgInfoTable -> ShowS Source # show :: StgInfoTable -> String Source # showList :: [ StgInfoTable ] -> ShowS Source #
Show ClosureType
Instance details Defined in GHC.Exts.Heap.ClosureTypes Methods showsPrec :: Int -> ClosureType -> ShowS Source # show :: ClosureType -> String Source # showList :: [ ClosureType ] -> ShowS Source #
Show Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods showsPrec :: Int -> Doc -> ShowS Source # show :: Doc -> String Source # showList :: [ Doc ] -> ShowS Source #
Show TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> TextDetails -> ShowS Source # show :: TextDetails -> String Source # showList :: [ TextDetails ] -> ShowS Source #
Show Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Style -> ShowS Source # show :: Style -> String Source # showList :: [ Style ] -> ShowS Source #
Show Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Mode -> ShowS Source # show :: Mode -> String Source # showList :: [ Mode ] -> ShowS Source #
Show FatalError
Instance details Defined in Protolude.Panic Methods showsPrec :: Int -> FatalError -> ShowS Source # show :: FatalError -> String Source # showList :: [ FatalError ] -> ShowS Source #
Show UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods showsPrec :: Int -> UnicodeException -> ShowS Source # show :: UnicodeException -> String Source # showList :: [ UnicodeException ] -> ShowS Source #
Show StdGen
Instance details Defined in System.Random.Internal Methods showsPrec :: Int -> StdGen -> ShowS Source # show :: StdGen -> String Source # showList :: [ StdGen ] -> ShowS Source #
Show ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModName -> ShowS Source # show :: ModName -> String Source # showList :: [ ModName ] -> ShowS Source #
Show PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PkgName -> ShowS Source # show :: PkgName -> String Source # showList :: [ PkgName ] -> ShowS Source #
Show Module
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Module -> ShowS Source # show :: Module -> String Source # showList :: [ Module ] -> ShowS Source #
Show OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> OccName -> ShowS Source # show :: OccName -> String Source # showList :: [ OccName ] -> ShowS Source #
Show NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameFlavour -> ShowS Source # show :: NameFlavour -> String Source # showList :: [ NameFlavour ] -> ShowS Source #
Show NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameSpace -> ShowS Source # show :: NameSpace -> String Source # showList :: [ NameSpace ] -> ShowS Source #
Show Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Loc -> ShowS Source # show :: Loc -> String Source # showList :: [ Loc ] -> ShowS Source #
Show Info
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Info -> ShowS Source # show :: Info -> String Source # showList :: [ Info ] -> ShowS Source #
Show ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModuleInfo -> ShowS Source # show :: ModuleInfo -> String Source # showList :: [ ModuleInfo ] -> ShowS Source #
Show Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Fixity -> ShowS Source # show :: Fixity -> String Source # showList :: [ Fixity ] -> ShowS Source #
Show FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FixityDirection -> ShowS Source # show :: FixityDirection -> String Source # showList :: [ FixityDirection ] -> ShowS Source #
Show Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Lit -> ShowS Source # show :: Lit -> String Source # showList :: [ Lit ] -> ShowS Source #
Show Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bytes -> ShowS Source # show :: Bytes -> String Source # showList :: [ Bytes ] -> ShowS Source #
Show Body
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Body -> ShowS Source # show :: Body -> String Source # showList :: [ Body ] -> ShowS Source #
Show Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Guard -> ShowS Source # show :: Guard -> String Source # showList :: [ Guard ] -> ShowS Source #
Show Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Stmt -> ShowS Source # show :: Stmt -> String Source # showList :: [ Stmt ] -> ShowS Source #
Show Range
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Range -> ShowS Source # show :: Range -> String Source # showList :: [ Range ] -> ShowS Source #
Show DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivClause -> ShowS Source # show :: DerivClause -> String Source # showList :: [ DerivClause ] -> ShowS Source #
Show DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivStrategy -> ShowS Source # show :: DerivStrategy -> String Source # showList :: [ DerivStrategy ] -> ShowS Source #
Show TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TypeFamilyHead -> ShowS Source # show :: TypeFamilyHead -> String Source # showList :: [ TypeFamilyHead ] -> ShowS Source #
Show TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TySynEqn -> ShowS Source # show :: TySynEqn -> String Source # showList :: [ TySynEqn ] -> ShowS Source #
Show Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Foreign -> ShowS Source # show :: Foreign -> String Source # showList :: [ Foreign ] -> ShowS Source #
Show Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Callconv -> ShowS Source # show :: Callconv -> String Source # showList :: [ Callconv ] -> ShowS Source #
Show Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Safety -> ShowS Source # show :: Safety -> String Source # showList :: [ Safety ] -> ShowS Source #
Show Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pragma -> ShowS Source # show :: Pragma -> String Source # showList :: [ Pragma ] -> ShowS Source #
Show Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Inline -> ShowS Source # show :: Inline -> String Source # showList :: [ Inline ] -> ShowS Source #
Show RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleMatch -> ShowS Source # show :: RuleMatch -> String Source # showList :: [ RuleMatch ] -> ShowS Source #
Show Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Phases -> ShowS Source # show :: Phases -> String Source # showList :: [ Phases ] -> ShowS Source #
Show RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleBndr -> ShowS Source # show :: RuleBndr -> String Source # showList :: [ RuleBndr ] -> ShowS Source #
Show AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnTarget -> ShowS Source # show :: AnnTarget -> String Source # showList :: [ AnnTarget ] -> ShowS Source #
Show SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceUnpackedness -> ShowS Source # show :: SourceUnpackedness -> String Source # showList :: [ SourceUnpackedness ] -> ShowS Source #
Show SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceStrictness -> ShowS Source # show :: SourceStrictness -> String Source # showList :: [ SourceStrictness ] -> ShowS Source #
Show DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DecidedStrictness -> ShowS Source # show :: DecidedStrictness -> String Source # showList :: [ DecidedStrictness ] -> ShowS Source #
Show Con
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Con -> ShowS Source # show :: Con -> String Source # showList :: [ Con ] -> ShowS Source #
Show Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bang -> ShowS Source # show :: Bang -> String Source # showList :: [ Bang ] -> ShowS Source #
Show PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynDir -> ShowS Source # show :: PatSynDir -> String Source # showList :: [ PatSynDir ] -> ShowS Source #
Show PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynArgs -> ShowS Source # show :: PatSynArgs -> String Source # showList :: [ PatSynArgs ] -> ShowS Source #
Show TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyVarBndr -> ShowS Source # show :: TyVarBndr -> String Source # showList :: [ TyVarBndr ] -> ShowS Source #
Show FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FamilyResultSig -> ShowS Source # show :: FamilyResultSig -> String Source # showList :: [ FamilyResultSig ] -> ShowS Source #
Show TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyLit -> ShowS Source # show :: TyLit -> String Source # showList :: [ TyLit ] -> ShowS Source #
Show Role
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Role -> ShowS Source # show :: Role -> String Source # showList :: [ Role ] -> ShowS Source #
Show AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnLookup -> ShowS Source # show :: AnnLookup -> String Source # showList :: [ AnnLookup ] -> ShowS Source #
Show Decoding
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> Decoding -> ShowS Source # show :: Decoding -> String Source # showList :: [ Decoding ] -> ShowS Source #
Show ShortText
Instance details Defined in Data.Text.Short.Internal Methods showsPrec :: Int -> ShortText -> ShowS Source # show :: ShortText -> String Source # showList :: [ ShortText ] -> ShowS Source #
Show ZonedTime
Instance details Defined in Data.Time.LocalTime.Internal.ZonedTime Methods showsPrec :: Int -> ZonedTime -> ShowS Source # show :: ZonedTime -> String Source # showList :: [ ZonedTime ] -> ShowS Source #
Show LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods showsPrec :: Int -> LocalTime -> ShowS Source # show :: LocalTime -> String Source # showList :: [ LocalTime ] -> ShowS Source #
Show TimeOfDay
Instance details Defined in Data.Time.LocalTime.Internal.TimeOfDay Methods showsPrec :: Int -> TimeOfDay -> ShowS Source # show :: TimeOfDay -> String Source # showList :: [ TimeOfDay ] -> ShowS Source #
Show TimeZone	This only shows the time zone name, or offset if the name is empty.
Instance details Defined in Data.Time.LocalTime.Internal.TimeZone Methods showsPrec :: Int -> TimeZone -> ShowS Source # show :: TimeZone -> String Source # showList :: [ TimeZone ] -> ShowS Source #
Show UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods showsPrec :: Int -> UnpackedUUID -> ShowS Source # show :: UnpackedUUID -> String Source # showList :: [UnpackedUUID] -> ShowS Source #
Show UUID	Pretty prints a `UUID` (without quotation marks). See also `toString` . `>>>` `show nil`"00000000-0000-0000-0000-000000000000"
Instance details Defined in Data.UUID.Types.Internal Methods showsPrec :: Int -> UUID -> ShowS Source # show :: UUID -> String Source # showList :: [ UUID ] -> ShowS Source #
Show CodePoint
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> CodePoint -> ShowS Source # show :: CodePoint -> String Source # showList :: [CodePoint] -> ShowS Source #
Show DecoderState
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> DecoderState -> ShowS Source # show :: DecoderState -> String Source # showList :: [DecoderState] -> ShowS Source #
Show CountFailure Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Size Methods showsPrec :: Int -> CountFailure -> ShowS Source # show :: CountFailure -> String Source # showList :: [ CountFailure ] -> ShowS Source #
Show ClosureTreeOptions Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Tree Methods showsPrec :: Int -> ClosureTreeOptions -> ShowS Source # show :: ClosureTreeOptions -> String Source # showList :: [ ClosureTreeOptions ] -> ShowS Source #
Show TraverseCyclicClosures Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Tree Methods showsPrec :: Int -> TraverseCyclicClosures -> ShowS Source # show :: TraverseCyclicClosures -> String Source # showList :: [ TraverseCyclicClosures ] -> ShowS Source #
Show TreeDepth Source #
Instance details Defined in Cardano.Prelude.GHC.Heap.Tree Methods showsPrec :: Int -> TreeDepth -> ShowS Source # show :: TreeDepth -> String Source # showList :: [ TreeDepth ] -> ShowS Source #
Show SchemaError Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods showsPrec :: Int -> SchemaError -> ShowS Source # show :: SchemaError -> String Source # showList :: [ SchemaError ] -> ShowS Source #
Show a => Show [a]	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> [a] -> ShowS Source # show :: [a] -> String Source # showList :: [[a]] -> ShowS Source #
Show a => Show ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS Source # show :: Maybe a -> String Source # showList :: [ Maybe a] -> ShowS Source #
Show a => Show ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods showsPrec :: Int -> Ratio a -> ShowS Source # show :: Ratio a -> String Source # showList :: [ Ratio a] -> ShowS Source #
Show ( Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> Ptr a -> ShowS Source # show :: Ptr a -> String Source # showList :: [ Ptr a] -> ShowS Source #
Show ( FunPtr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> FunPtr a -> ShowS Source # show :: FunPtr a -> String Source # showList :: [ FunPtr a] -> ShowS Source #
Show p => Show ( Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Par1 p -> ShowS Source # show :: Par1 p -> String Source # showList :: [ Par1 p] -> ShowS Source #
Show a => Show ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods showsPrec :: Int -> Solo a -> ShowS Source # show :: Solo a -> String Source # showList :: [ Solo a] -> ShowS Source #
Show a => Show ( IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> IResult a -> ShowS Source # show :: IResult a -> String Source # showList :: [ IResult a] -> ShowS Source #
Show a => Show ( Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Result a -> ShowS Source # show :: Result a -> String Source # showList :: [ Result a] -> ShowS Source #
Show v => Show ( KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods showsPrec :: Int -> KeyMap v -> ShowS Source # show :: KeyMap v -> String Source # showList :: [ KeyMap v] -> ShowS Source #
Show a => Show ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods showsPrec :: Int -> Complex a -> ShowS Source # show :: Complex a -> String Source # showList :: [ Complex a] -> ShowS Source #
Show a => Show ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Min a -> ShowS Source # show :: Min a -> String Source # showList :: [ Min a] -> ShowS Source #
Show a => Show ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Max a -> ShowS Source # show :: Max a -> String Source # showList :: [ Max a] -> ShowS Source #
Show a => Show ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> First a -> ShowS Source # show :: First a -> String Source # showList :: [ First a] -> ShowS Source #
Show a => Show ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Last a -> ShowS Source # show :: Last a -> String Source # showList :: [ Last a] -> ShowS Source #
Show m => Show ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> WrappedMonoid m -> ShowS Source # show :: WrappedMonoid m -> String Source # showList :: [ WrappedMonoid m] -> ShowS Source #
Show a => Show ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Option a -> ShowS Source # show :: Option a -> String Source # showList :: [ Option a] -> ShowS Source #
Show a => Show ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods showsPrec :: Int -> ZipList a -> ShowS Source # show :: ZipList a -> String Source # showList :: [ ZipList a] -> ShowS Source #
Show a => Show ( Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS Source # show :: Identity a -> String Source # showList :: [ Identity a] -> ShowS Source #
Show a => Show ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> First a -> ShowS Source # show :: First a -> String Source # showList :: [ First a] -> ShowS Source #
Show a => Show ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Last a -> ShowS Source # show :: Last a -> String Source # showList :: [ Last a] -> ShowS Source #
Show a => Show ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Dual a -> ShowS Source # show :: Dual a -> String Source # showList :: [ Dual a] -> ShowS Source #
Show a => Show ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Sum a -> ShowS Source # show :: Sum a -> String Source # showList :: [ Sum a] -> ShowS Source #
Show a => Show ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Product a -> ShowS Source # show :: Product a -> String Source # showList :: [ Product a] -> ShowS Source #
Show a => Show ( Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods showsPrec :: Int -> Down a -> ShowS Source # show :: Down a -> String Source # showList :: [ Down a] -> ShowS Source #
Show a => Show ( NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS Source # show :: NonEmpty a -> String Source # showList :: [ NonEmpty a] -> ShowS Source #
Show a => Show ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods showsPrec :: Int -> IntMap a -> ShowS Source # show :: IntMap a -> String Source # showList :: [ IntMap a] -> ShowS Source #
Show a => Show ( Tree a)
Instance details Defined in Data.Tree Methods showsPrec :: Int -> Tree a -> ShowS Source # show :: Tree a -> String Source # showList :: [ Tree a] -> ShowS Source #
Show a => Show ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS Source # show :: Seq a -> String Source # showList :: [ Seq a] -> ShowS Source #
Show a => Show ( ViewL a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewL a -> ShowS Source # show :: ViewL a -> String Source # showList :: [ ViewL a] -> ShowS Source #
Show a => Show ( ViewR a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewR a -> ShowS Source # show :: ViewR a -> String Source # showList :: [ ViewR a] -> ShowS Source #
Show a => Show ( Set a)
Instance details Defined in Data.Set.Internal Methods showsPrec :: Int -> Set a -> ShowS Source # show :: Set a -> String Source # showList :: [ Set a] -> ShowS Source #
Show1 f => Show ( Fix f)
Instance details Defined in Data.Fix Methods showsPrec :: Int -> Fix f -> ShowS Source # show :: Fix f -> String Source # showList :: [ Fix f] -> ShowS Source #
( Functor f, Show1 f) => Show ( Mu f)
Instance details Defined in Data.Fix Methods showsPrec :: Int -> Mu f -> ShowS Source # show :: Mu f -> String Source # showList :: [ Mu f] -> ShowS Source #
( Functor f, Show1 f) => Show ( Nu f)
Instance details Defined in Data.Fix Methods showsPrec :: Int -> Nu f -> ShowS Source # show :: Nu f -> String Source # showList :: [ Nu f] -> ShowS Source #
Show a => Show ( DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods showsPrec :: Int -> DNonEmpty a -> ShowS Source # show :: DNonEmpty a -> String Source # showList :: [ DNonEmpty a] -> ShowS Source #
Show a => Show ( DList a)
Instance details Defined in Data.DList.Internal Methods showsPrec :: Int -> DList a -> ShowS Source # show :: DList a -> String Source # showList :: [ DList a] -> ShowS Source #
Show a => Show ( Hex a)
Instance details Defined in Data.Text.Format.Types Methods showsPrec :: Int -> Hex a -> ShowS Source # show :: Hex a -> String Source # showList :: [ Hex a] -> ShowS Source #
Show a => Show ( Shown a)
Instance details Defined in Data.Text.Format.Types Methods showsPrec :: Int -> Shown a -> ShowS Source # show :: Shown a -> String Source # showList :: [ Shown a] -> ShowS Source #
Show b => Show ( GenClosure b)
Instance details Defined in GHC.Exts.Heap.Closures Methods showsPrec :: Int -> GenClosure b -> ShowS Source # show :: GenClosure b -> String Source # showList :: [ GenClosure b] -> ShowS Source #
Show a => Show ( Hashed a)
Instance details Defined in Data.Hashable.Class Methods showsPrec :: Int -> Hashed a -> ShowS Source # show :: Hashed a -> String Source # showList :: [ Hashed a] -> ShowS Source #
Show ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Doc a -> ShowS Source # show :: Doc a -> String Source # showList :: [ Doc a] -> ShowS Source #
Show a => Show ( AnnotDetails a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> AnnotDetails a -> ShowS Source # show :: AnnotDetails a -> String Source # showList :: [ AnnotDetails a] -> ShowS Source #
Show a => Show ( Span a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Span a -> ShowS Source # show :: Span a -> String Source # showList :: [ Span a] -> ShowS Source #
( 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 Source # show :: PrimArray a -> String Source # showList :: [ PrimArray a] -> ShowS Source #
Show a => Show ( SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods showsPrec :: Int -> SmallArray a -> ShowS Source # show :: SmallArray a -> String Source # showList :: [ SmallArray a] -> ShowS Source #
Show a => Show ( Array a)
Instance details Defined in Data.Primitive.Array Methods showsPrec :: Int -> Array a -> ShowS Source # show :: Array a -> String Source # showList :: [ Array a] -> ShowS Source #
Show g => Show ( AtomicGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> AtomicGen g -> ShowS Source # show :: AtomicGen g -> String Source # showList :: [ AtomicGen g] -> ShowS Source #
Show g => Show ( IOGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> IOGen g -> ShowS Source # show :: IOGen g -> String Source # showList :: [ IOGen g] -> ShowS Source #
Show g => Show ( STGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> STGen g -> ShowS Source # show :: STGen g -> String Source # showList :: [ STGen g] -> ShowS Source #
Show g => Show ( TGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> TGen g -> ShowS Source # show :: TGen g -> String Source # showList :: [ TGen g] -> ShowS Source #
Show g => Show ( StateGen g)
Instance details Defined in System.Random.Internal Methods showsPrec :: Int -> StateGen g -> ShowS Source # show :: StateGen g -> String Source # showList :: [ StateGen g] -> ShowS Source #
Show a => Show ( Maybe a)
Instance details Defined in Data.Strict.Maybe Methods showsPrec :: Int -> Maybe a -> ShowS Source # show :: Maybe a -> String Source # showList :: [ Maybe a] -> ShowS Source #
Show a => Show ( HashSet a)
Instance details Defined in Data.HashSet.Internal Methods showsPrec :: Int -> HashSet a -> ShowS Source # show :: HashSet a -> String Source # showList :: [ HashSet a] -> ShowS Source #
( Show a, Storable a) => Show ( Vector a)
Instance details Defined in Data.Vector.Storable Methods showsPrec :: Int -> Vector a -> ShowS Source # show :: Vector a -> String Source # showList :: [ Vector a] -> ShowS Source #
( Show a, Prim a) => Show ( Vector a)
Instance details Defined in Data.Vector.Primitive Methods showsPrec :: Int -> Vector a -> ShowS Source # show :: Vector a -> String Source # showList :: [ Vector a] -> ShowS Source #
Show a => Show ( Vector a)
Instance details Defined in Data.Vector Methods showsPrec :: Int -> Vector a -> ShowS Source # show :: Vector a -> String Source # showList :: [ Vector a] -> ShowS Source #
( 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 Source # show :: Either a b -> String Source # showList :: [ Either a b] -> ShowS Source #
Show ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> V1 p -> ShowS Source # show :: V1 p -> String Source # showList :: [ V1 p] -> ShowS Source #
Show ( U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> U1 p -> ShowS Source # show :: U1 p -> String Source # showList :: [ U1 p] -> ShowS Source #
Show ( TypeRep a)
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> TypeRep a -> ShowS Source # show :: TypeRep a -> String Source # showList :: [ TypeRep a] -> ShowS Source #
( Show a, Show b) => Show (a, b)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b) -> ShowS Source # show :: (a, b) -> String Source # showList :: [(a, b)] -> ShowS Source #
( Show k, Show a) => Show ( Map k a)
Instance details Defined in Data.Map.Internal Methods showsPrec :: Int -> Map k a -> ShowS Source # show :: Map k a -> String Source # showList :: [ Map k a] -> ShowS Source #
( Show k, Show v) => Show ( HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods showsPrec :: Int -> HashMap k v -> ShowS Source # show :: HashMap k v -> String Source # showList :: [ HashMap k v] -> ShowS Source #
Show ( ST s a)	Since: base-2.1
Instance details Defined in GHC.ST Methods showsPrec :: Int -> ST s a -> ShowS Source # show :: ST s a -> String Source # showList :: [ ST s a] -> ShowS Source #
( Ix ix, Show ix, Show e, IArray UArray e) => Show ( UArray ix e)
Instance details Defined in Data.Array.Base Methods showsPrec :: Int -> UArray ix e -> ShowS Source # show :: UArray ix e -> String Source # showList :: [ UArray ix e] -> ShowS Source #
( Ix a, Show a, Show b) => Show ( Array a b)	Since: base-2.1
Instance details Defined in GHC.Arr Methods showsPrec :: Int -> Array a b -> ShowS Source # show :: Array a b -> String Source # showList :: [ Array a b] -> ShowS Source #
( Show i, Show r) => Show ( IResult i r)
Instance details Defined in Data.Attoparsec.Internal.Types Methods showsPrec :: Int -> IResult i r -> ShowS Source # show :: IResult i r -> String Source # showList :: [ IResult i r] -> ShowS Source #
HasResolution a => Show ( Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods showsPrec :: Int -> Fixed a -> ShowS Source # show :: Fixed a -> String Source # showList :: [ Fixed a] -> ShowS Source #
( Show a, Show b) => Show ( Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Arg a b -> ShowS Source # show :: Arg a b -> String Source # showList :: [ Arg a b] -> ShowS Source #
Show ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods showsPrec :: Int -> Proxy s -> ShowS Source # show :: Proxy s -> String Source # showList :: [ Proxy s] -> ShowS Source #
( Show1 m, Show a) => Show ( ListT m a)
Instance details Defined in Control.Monad.Trans.List Methods showsPrec :: Int -> ListT m a -> ShowS Source # show :: ListT m a -> String Source # showList :: [ ListT m a] -> ShowS Source #
( Show a, Show b) => Show ( These a b)
Instance details Defined in Data.These Methods showsPrec :: Int -> These a b -> ShowS Source # show :: These a b -> String Source # showList :: [ These a b] -> ShowS Source #
( Show a, Show b) => Show ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods showsPrec :: Int -> Pair a b -> ShowS Source # show :: Pair a b -> String Source # showList :: [ Pair a b] -> ShowS Source #
( Show a, Show b) => Show ( These a b)
Instance details Defined in Data.Strict.These Methods showsPrec :: Int -> These a b -> ShowS Source # show :: These a b -> String Source # showList :: [ These a b] -> ShowS Source #
( Show a, Show b) => Show ( Either a b)
Instance details Defined in Data.Strict.Either Methods showsPrec :: Int -> Either a b -> ShowS Source # show :: Either a b -> String Source # showList :: [ Either a b] -> ShowS Source #
( Show1 m, Show a) => Show ( MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods showsPrec :: Int -> MaybeT m a -> ShowS Source # show :: MaybeT m a -> String Source # showList :: [ MaybeT m a] -> ShowS Source #
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 Source # show :: Rec1 f p -> String Source # showList :: [ Rec1 f p] -> ShowS Source #
Show ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS Source # show :: URec Char p -> String Source # showList :: [ URec Char p] -> ShowS Source #
Show ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS Source # show :: URec Double p -> String Source # showList :: [ URec Double p] -> ShowS Source #
Show ( URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS Source # show :: URec Float p -> String Source # showList :: [ URec Float p] -> ShowS Source #
Show ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS Source # show :: URec Int p -> String Source # showList :: [ URec Int p] -> ShowS Source #
Show ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS Source # show :: URec Word p -> String Source # showList :: [ URec Word p] -> ShowS Source #
( 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 Source # show :: (a, b, c) -> String Source # showList :: [(a, b, c)] -> ShowS Source #
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 Source # show :: Const a b -> String Source # showList :: [ Const a b] -> ShowS Source #
Show (f a) => Show ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Ap f a -> ShowS Source # show :: Ap f a -> String Source # showList :: [ Ap f a] -> ShowS Source #
Show (f a) => Show ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Alt f a -> ShowS Source # show :: Alt f a -> String Source # showList :: [ Alt f a] -> ShowS Source #
Show ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods showsPrec :: Int -> Coercion a b -> ShowS Source # show :: Coercion a b -> String Source # showList :: [ Coercion a b] -> ShowS Source #
Show (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~: b) -> ShowS Source # show :: (a :~: b) -> String Source # showList :: [a :~: b] -> ShowS Source #
( Show1 f, Show a) => Show ( IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods showsPrec :: Int -> IdentityT f a -> ShowS Source # show :: IdentityT f a -> String Source # showList :: [ IdentityT f a] -> ShowS Source #
( Show e, Show1 m, Show a) => Show ( ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods showsPrec :: Int -> ErrorT e m a -> ShowS Source # show :: ErrorT e m a -> String Source # showList :: [ ErrorT e m a] -> ShowS Source #
( Show e, Show1 m, Show a) => Show ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods showsPrec :: Int -> ExceptT e m a -> ShowS Source # show :: ExceptT e m a -> String Source # showList :: [ ExceptT e m a] -> ShowS Source #
( Show w, Show1 m, Show a) => Show ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods showsPrec :: Int -> WriterT w m a -> ShowS Source # show :: WriterT w m a -> String Source # showList :: [ WriterT w m a] -> ShowS Source #
( Show w, Show1 m, Show a) => Show ( WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods showsPrec :: Int -> WriterT w m a -> ShowS Source # show :: WriterT w m a -> String Source # showList :: [ WriterT w m a] -> ShowS Source #
Show b => Show ( Tagged s b)
Instance details Defined in Data.Tagged Methods showsPrec :: Int -> Tagged s b -> ShowS Source # show :: Tagged s b -> String Source # showList :: [ Tagged s b] -> ShowS Source #
( Show1 f, Show1 g, Show a) => Show ( These1 f g a)
Instance details Defined in Data.Functor.These Methods showsPrec :: Int -> These1 f g a -> ShowS Source # show :: These1 f g a -> String Source # showList :: [ These1 f g a] -> ShowS Source #
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 Source # show :: K1 i c p -> String Source # showList :: [ K1 i c p] -> ShowS Source #
( 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 Source # show :: (f :+: g) p -> String Source # showList :: [(f :+: g) p] -> ShowS Source #
( 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 Source # show :: (f :: g) p -> String Source # showList :: [(f :*: g) p] -> ShowS Source #
( 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 Source # show :: (a, b, c, d) -> String Source # showList :: [(a, b, c, d)] -> ShowS Source #
( Show1 f, Show1 g, Show a) => Show ( Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods showsPrec :: Int -> Product f g a -> ShowS Source # show :: Product f g a -> String Source # showList :: [ Product f g a] -> ShowS Source #
( Show1 f, Show1 g, Show a) => Show ( Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods showsPrec :: Int -> Sum f g a -> ShowS Source # show :: Sum f g a -> String Source # showList :: [ Sum f g a] -> ShowS Source #
Show (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~~: b) -> ShowS Source # show :: (a :~~: b) -> String Source # showList :: [a :~~: b] -> ShowS Source #
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 Source # show :: M1 i c f p -> String Source # showList :: [ M1 i c f p] -> ShowS Source #
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 Source # show :: (f :.: g) p -> String Source # showList :: [(f :.: g) p] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e) -> String Source # showList :: [(a, b, c, d, e)] -> ShowS Source #
( Show1 f, Show1 g, Show a) => Show ( Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods showsPrec :: Int -> Compose f g a -> ShowS Source # show :: Compose f g a -> String Source # showList :: [ Compose f g a] -> ShowS Source #
Show (p b a) => Show ( Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods showsPrec :: Int -> Flip p a b -> ShowS Source # show :: Flip p a b -> String Source # showList :: [ Flip p a b] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f) -> String Source # showList :: [(a, b, c, d, e, f)] -> ShowS Source #
( Show (p a b), Show (q a b)) => Show ( Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods showsPrec :: Int -> Sum p q a b -> ShowS Source # show :: Sum p q a b -> String Source # showList :: [ Sum p q a b] -> ShowS Source #
( Show (f a b), Show (g a b)) => Show ( Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods showsPrec :: Int -> Product f g a b -> ShowS Source # show :: Product f g a b -> String Source # showList :: [ Product f g a b] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g) -> String Source # showList :: [(a, b, c, d, e, f, g)] -> ShowS Source #
Show (f (p a b)) => Show ( Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods showsPrec :: Int -> Tannen f p a b -> ShowS Source # show :: Tannen f p a b -> String Source # showList :: [ Tannen f p a b] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h) -> String Source # showList :: [(a, b, c, d, e, f, g, h)] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h, i) -> String Source # showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS Source #
Show (p (f a) (g b)) => Show ( Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods showsPrec :: Int -> Biff p f g a b -> ShowS Source # show :: Biff p f g a b -> String Source # showList :: [ Biff p f g a b] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h, i, j) -> String Source # showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h, i, j, k) -> String Source # showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String Source # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String Source # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String Source # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS Source #
( 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 Source # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String Source # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS Source #

class Typeable (a :: k) Source #

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

class Monad m => MonadFail (m :: Type -> Type ) Source #

When a value is bound in do -notation, the pattern on the left hand side of <- might not match. In this case, this class provides a function to recover.

A Monad without a MonadFail instance may only be used in conjunction with pattern that always match, such as newtypes, tuples, data types with only a single data constructor, and irrefutable patterns ( ~pat ).

Instances of MonadFail should satisfy the following law: fail s should be a left zero for >>= ,

fail s >>= f  =  fail s

If your Monad is also MonadPlus , a popular definition is

fail _ = mzero

Since: base-4.9.0.0

Minimal complete definition

fail

Instances

Instances details

MonadFail []	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> [a] Source #
MonadFail Maybe	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> Maybe a Source #
MonadFail IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> IO a Source #
MonadFail Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fail :: String -> Q a Source #
MonadFail IResult
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> IResult a Source #
MonadFail Result
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> Result a Source #
MonadFail Parser
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> Parser a Source #
MonadFail ReadP	Since: base-4.9.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fail :: String -> ReadP a Source #
MonadFail DList
Instance details Defined in Data.DList.Internal Methods fail :: String -> DList a Source #
MonadFail SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fail :: String -> SmallArray a Source #
MonadFail Array
Instance details Defined in Data.Primitive.Array Methods fail :: String -> Array a Source #
MonadFail Vector	Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods fail :: String -> Vector a Source #
MonadFail P	Since: base-4.9.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fail :: String -> P a Source #
MonadFail ( ST s)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods fail :: String -> ST s a Source #
MonadFail ( Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods fail :: String -> Parser i a Source #
MonadFail ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods fail :: String -> Decoder s a Source #
Monad m => MonadFail ( ListT m)
Instance details Defined in Control.Monad.Trans.List Methods fail :: String -> ListT m a Source #
Monad m => MonadFail ( MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fail :: String -> MaybeT m a Source #
MonadFail f => MonadFail ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fail :: String -> Ap f a Source #
MonadFail m => MonadFail ( IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fail :: String -> IdentityT m a Source #
( Monad m, Error e) => MonadFail ( ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods fail :: String -> ErrorT e m a Source #
MonadFail m => MonadFail ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fail :: String -> ExceptT e m a Source #
MonadFail m => MonadFail ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fail :: String -> ReaderT r m a Source #
MonadFail m => MonadFail ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fail :: String -> StateT s m a Source #
MonadFail m => MonadFail ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fail :: String -> StateT s m a Source #
( Monoid w, MonadFail m) => MonadFail ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods fail :: String -> WriterT w m a Source #
( Monoid w, MonadFail m) => MonadFail ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods fail :: String -> WriterT w m a Source #
( Monoid w, MonadFail m) => MonadFail ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods fail :: String -> RWST r w s m a Source #
( Monoid w, MonadFail m) => MonadFail ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods fail :: String -> RWST r w s m a Source #

class IsString a Source #

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

Minimal complete definition

fromString

Instances

Instances details

IsString ByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Internal Methods fromString :: String -> ByteString Source #
IsString ByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Lazy.Internal Methods fromString :: String -> ByteString Source #
IsString Builder
Instance details Defined in Data.Text.Internal.Builder Methods fromString :: String -> Builder Source #
IsString Value
Instance details Defined in Data.Aeson.Types.Internal Methods fromString :: String -> Value Source #
IsString Key
Instance details Defined in Data.Aeson.Key Methods fromString :: String -> Key Source #
IsString ShortByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Short.Internal Methods fromString :: String -> ShortByteString Source #
IsString JSString
Instance details Defined in Text.JSON.Canonical.Types Methods fromString :: String -> JSString Source #
IsString ByteArray
Instance details Defined in Codec.CBOR.ByteArray Methods fromString :: String -> ByteArray Source #
IsString SlicedByteArray
Instance details Defined in Codec.CBOR.ByteArray.Sliced Methods fromString :: String -> SlicedByteArray Source #
IsString Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods fromString :: String -> Doc Source #
IsString ShortText	Note : Surrogate pairs ( `[U+D800 .. U+DFFF]` ) in string literals are replaced by U+FFFD. This matches the behaviour of `IsString` instance for `Text` .
Instance details Defined in Data.Text.Short.Internal Methods fromString :: String -> ShortText Source #
a ~ Char => IsString [a]	`(a ~ Char)` context was introduced in `4.9.0.0` Since: base-2.1
Instance details Defined in Data.String Methods fromString :: String -> [a] Source #
IsString a => IsString ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a Source #
a ~ Char => IsString ( Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq a Source #
a ~ Char => IsString ( DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods fromString :: String -> DNonEmpty a Source #
a ~ Char => IsString ( DList a)
Instance details Defined in Data.DList.Internal Methods fromString :: String -> DList a Source #
( IsString a, Hashable a) => IsString ( Hashed a)
Instance details Defined in Data.Hashable.Class Methods fromString :: String -> Hashed a Source #
IsString ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fromString :: String -> Doc a Source #
a ~ r => IsString ( Format r a)	Useful instance for writing format string. With this you can write `Foo` instead of `now "Foo!"` .
Instance details Defined in Formatting.Internal Methods fromString :: String -> Format r a Source #
IsString a => IsString ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Const a b Source #
IsString a => IsString ( Tagged s a)
Instance details Defined in Data.Tagged Methods fromString :: String -> Tagged s a Source #

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

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

Lift a value.

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

Sequential application.

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

Using ApplicativeDo : ' fs <*> as ' can be understood as the do expression

do f <- fs
   a <- as
   pure (f a)

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

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 .

Using ApplicativeDo : ' liftA2 f as bs ' can be understood as the do expression

do a <- as
   b <- bs
   pure (f a b)

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

Sequence actions, discarding the value of the first argument.

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

do as
   bs

This is a tad complicated for our ApplicativeDo extension which will give it a Monad constraint. For an Applicative constraint we write it of the form

do _ <- as
   b <- bs
   pure b

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

Sequence actions, discarding the value of the second argument.

Using ApplicativeDo : ' as <* bs ' can be understood as the do expression

do a <- as
   bs
   pure a

Instances

Instances details

Applicative []	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> [a] Source # (<>) :: [a -> b] -> [a] -> [b] Source # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] Source # (>) :: [a] -> [b] -> [b] Source # (<*) :: [a] -> [b] -> [a] Source #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a Source # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c Source # (>) :: Maybe a -> Maybe b -> Maybe b Source # (<*) :: Maybe a -> Maybe b -> Maybe a Source #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a Source # (<>) :: IO (a -> b) -> IO a -> IO b Source # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c Source # (>) :: IO a -> IO b -> IO b Source # (<*) :: IO a -> IO b -> IO a Source #
Applicative Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Par1 a Source # (<>) :: Par1 (a -> b) -> Par1 a -> Par1 b Source # liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source # (>) :: Par1 a -> Par1 b -> Par1 b Source # (<*) :: Par1 a -> Par1 b -> Par1 a Source #
Applicative Q
Instance details Defined in Language.Haskell.TH.Syntax Methods pure :: a -> Q a Source # (<>) :: Q (a -> b) -> Q a -> Q b Source # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c Source # (>) :: Q a -> Q b -> Q b Source # (<*) :: Q a -> Q b -> Q a Source #
Applicative Solo
Instance details Defined in Data.Tuple.Solo Methods pure :: a -> Solo a Source # (<>) :: Solo (a -> b) -> Solo a -> Solo b Source # liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c Source # (>) :: Solo a -> Solo b -> Solo b Source # (<*) :: Solo a -> Solo b -> Solo a Source #
Applicative IResult
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> IResult a Source # (<>) :: IResult (a -> b) -> IResult a -> IResult b Source # liftA2 :: (a -> b -> c) -> IResult a -> IResult b -> IResult c Source # (>) :: IResult a -> IResult b -> IResult b Source # (<*) :: IResult a -> IResult b -> IResult a Source #
Applicative Result
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> Result a Source # (<>) :: Result (a -> b) -> Result a -> Result b Source # liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c Source # (>) :: Result a -> Result b -> Result b Source # (<*) :: Result a -> Result b -> Result a Source #
Applicative Parser
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> Parser a Source # (<>) :: Parser (a -> b) -> Parser a -> Parser b Source # liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c Source # (>) :: Parser a -> Parser b -> Parser b Source # (<*) :: Parser a -> Parser b -> Parser a Source #
Applicative Concurrently
Instance details Defined in Control.Concurrent.Async Methods pure :: a -> Concurrently a Source # (<>) :: Concurrently (a -> b) -> Concurrently a -> Concurrently b Source # liftA2 :: (a -> b -> c) -> Concurrently a -> Concurrently b -> Concurrently c Source # (>) :: Concurrently a -> Concurrently b -> Concurrently b Source # (<*) :: Concurrently a -> Concurrently b -> Concurrently a Source #
Applicative Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods pure :: a -> Complex a Source # (<>) :: Complex (a -> b) -> Complex a -> Complex b Source # liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c Source # (>) :: Complex a -> Complex b -> Complex b Source # (<*) :: Complex a -> Complex b -> Complex a Source #
Applicative Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Min a Source # (<>) :: Min (a -> b) -> Min a -> Min b Source # liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c Source # (>) :: Min a -> Min b -> Min b Source # (<*) :: Min a -> Min b -> Min a Source #
Applicative Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Max a Source # (<>) :: Max (a -> b) -> Max a -> Max b Source # liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c Source # (>) :: Max a -> Max b -> Max b Source # (<*) :: Max a -> Max b -> Max a Source #
Applicative First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> First a Source # (<>) :: First (a -> b) -> First a -> First b Source # liftA2 :: (a -> b -> c) -> First a -> First b -> First c Source # (>) :: First a -> First b -> First b Source # (<*) :: First a -> First b -> First a Source #
Applicative Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Last a Source # (<>) :: Last (a -> b) -> Last a -> Last b Source # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source # (>) :: Last a -> Last b -> Last b Source # (<*) :: Last a -> Last b -> Last a Source #
Applicative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Option a Source # (<>) :: Option (a -> b) -> Option a -> Option b Source # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c Source # (>) :: Option a -> Option b -> Option b Source # (<*) :: Option a -> Option b -> Option a Source #
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 Source # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c Source # (>) :: ZipList a -> ZipList b -> ZipList b Source # (<*) :: ZipList a -> ZipList b -> ZipList a Source #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a Source # (<>) :: Identity (a -> b) -> Identity a -> Identity b Source # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source # (>) :: Identity a -> Identity b -> Identity b Source # (<*) :: Identity a -> Identity b -> Identity a Source #
Applicative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods pure :: a -> STM a Source # (<>) :: STM (a -> b) -> STM a -> STM b Source # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c Source # (>) :: STM a -> STM b -> STM b Source # (<*) :: STM a -> STM b -> STM a Source #
Applicative First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> First a Source # (<>) :: First (a -> b) -> First a -> First b Source # liftA2 :: (a -> b -> c) -> First a -> First b -> First c Source # (>) :: First a -> First b -> First b Source # (<*) :: First a -> First b -> First a Source #
Applicative Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Last a Source # (<>) :: Last (a -> b) -> Last a -> Last b Source # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source # (>) :: Last a -> Last b -> Last b Source # (<*) :: Last a -> Last b -> Last a Source #
Applicative Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Dual a Source # (<>) :: Dual (a -> b) -> Dual a -> Dual b Source # liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c Source # (>) :: Dual a -> Dual b -> Dual b Source # (<*) :: Dual a -> Dual b -> Dual a Source #
Applicative Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Sum a Source # (<>) :: Sum (a -> b) -> Sum a -> Sum b Source # liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c Source # (>) :: Sum a -> Sum b -> Sum b Source # (<*) :: Sum a -> Sum b -> Sum a Source #
Applicative Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Product a Source # (<>) :: Product (a -> b) -> Product a -> Product b Source # liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c Source # (>) :: Product a -> Product b -> Product b Source # (<*) :: Product a -> Product b -> Product a Source #
Applicative Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods pure :: a -> Down a Source # (<>) :: Down (a -> b) -> Down a -> Down b Source # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c Source # (>) :: Down a -> Down b -> Down b Source # (<*) :: Down a -> Down b -> Down a Source #
Applicative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> ReadP a Source # (<>) :: ReadP (a -> b) -> ReadP a -> ReadP b Source # liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c Source # (>) :: ReadP a -> ReadP b -> ReadP b Source # (<*) :: ReadP a -> ReadP b -> ReadP a Source #
Applicative NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods pure :: a -> NonEmpty a Source # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source #
Applicative Tree
Instance details Defined in Data.Tree Methods pure :: a -> Tree a Source # (<>) :: Tree (a -> b) -> Tree a -> Tree b Source # liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c Source # (>) :: Tree a -> Tree b -> Tree b Source # (<*) :: Tree a -> Tree b -> Tree a Source #
Applicative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a Source # (<>) :: Seq (a -> b) -> Seq a -> Seq b Source # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source # (>) :: Seq a -> Seq b -> Seq b Source # (<*) :: Seq a -> Seq b -> Seq a Source #
Applicative DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods pure :: a -> DNonEmpty a Source # (<>) :: DNonEmpty (a -> b) -> DNonEmpty a -> DNonEmpty b Source # liftA2 :: (a -> b -> c) -> DNonEmpty a -> DNonEmpty b -> DNonEmpty c Source # (>) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty b Source # (<*) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty a Source #
Applicative DList
Instance details Defined in Data.DList.Internal Methods pure :: a -> DList a Source # (<>) :: DList (a -> b) -> DList a -> DList b Source # liftA2 :: (a -> b -> c) -> DList a -> DList b -> DList c Source # (>) :: DList a -> DList b -> DList b Source # (<*) :: DList a -> DList b -> DList a Source #
Applicative SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods pure :: a -> SmallArray a Source # (<>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b Source # liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c Source # (>) :: SmallArray a -> SmallArray b -> SmallArray b Source # (<*) :: SmallArray a -> SmallArray b -> SmallArray a Source #
Applicative Array
Instance details Defined in Data.Primitive.Array Methods pure :: a -> Array a Source # (<>) :: Array (a -> b) -> Array a -> Array b Source # liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c Source # (>) :: Array a -> Array b -> Array b Source # (<*) :: Array a -> Array b -> Array a Source #
Applicative Vector
Instance details Defined in Data.Vector Methods pure :: a -> Vector a Source # (<>) :: Vector (a -> b) -> Vector a -> Vector b Source # liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c Source # (>) :: Vector a -> Vector b -> Vector b Source # (<*) :: Vector a -> Vector b -> Vector a Source #
Applicative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> P a Source # (<>) :: P (a -> b) -> P a -> P b Source # liftA2 :: (a -> b -> c) -> P a -> P b -> P c Source # (>) :: P a -> P b -> P b Source # (<*) :: P a -> P b -> P a Source #
Applicative ( Either e)	Since: base-3.0
Instance details Defined in Data.Either Methods pure :: a -> Either e a Source # (<>) :: Either e (a -> b) -> Either e a -> Either e b Source # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c Source # (>) :: Either e a -> Either e b -> Either e b Source # (<*) :: Either e a -> Either e b -> Either e a Source #
Applicative ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> U1 a Source # (<>) :: U1 (a -> b) -> U1 a -> U1 b Source # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source # (>) :: U1 a -> U1 b -> U1 b Source # (<*) :: U1 a -> U1 b -> U1 a Source #
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) Source # (<>) :: (a, a0 -> b) -> (a, a0) -> (a, b) Source # liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) Source # (>) :: (a, a0) -> (a, b) -> (a, b) Source # (<*) :: (a, a0) -> (a, b) -> (a, a0) Source #
Applicative ( ST s)	Since: base-4.4.0.0
Instance details Defined in GHC.ST Methods pure :: a -> ST s a Source # (<>) :: ST s (a -> b) -> ST s a -> ST s b Source # liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c Source # (>) :: ST s a -> ST s b -> ST s b Source # (<*) :: ST s a -> ST s b -> ST s a Source #
Applicative ( Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods pure :: a -> Parser i a Source # (<>) :: Parser i (a -> b) -> Parser i a -> Parser i b Source # liftA2 :: (a -> b -> c) -> Parser i a -> Parser i b -> Parser i c Source # (>) :: Parser i a -> Parser i b -> Parser i b Source # (<*) :: Parser i a -> Parser i b -> Parser i a Source #
Monad m => Applicative ( WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a Source # (<>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source # (>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source #
Arrow a => Applicative ( ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 Source # (<>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c Source # (>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #
Applicative ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods pure :: a -> Proxy a Source # (<>) :: Proxy (a -> b) -> Proxy a -> Proxy b Source # liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c Source # (>) :: Proxy a -> Proxy b -> Proxy b Source # (<*) :: Proxy a -> Proxy b -> Proxy a Source #
Applicative ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods pure :: a -> Decoder s a Source # (<>) :: Decoder s (a -> b) -> Decoder s a -> Decoder s b Source # liftA2 :: (a -> b -> c) -> Decoder s a -> Decoder s b -> Decoder s c Source # (>) :: Decoder s a -> Decoder s b -> Decoder s b Source # (<*) :: Decoder s a -> Decoder s b -> Decoder s a Source #
Applicative m => Applicative ( ListT m)
Instance details Defined in Control.Monad.Trans.List Methods pure :: a -> ListT m a Source # (<>) :: ListT m (a -> b) -> ListT m a -> ListT m b Source # liftA2 :: (a -> b -> c) -> ListT m a -> ListT m b -> ListT m c Source # (>) :: ListT m a -> ListT m b -> ListT m b Source # (<*) :: ListT m a -> ListT m b -> ListT m a Source #
Semigroup a => Applicative ( These a)
Instance details Defined in Data.These Methods pure :: a0 -> These a a0 Source # (<>) :: These a (a0 -> b) -> These a a0 -> These a b Source # liftA2 :: (a0 -> b -> c) -> These a a0 -> These a b -> These a c Source # (>) :: These a a0 -> These a b -> These a b Source # (<*) :: These a a0 -> These a b -> These a a0 Source #
Semigroup a => Applicative ( These a)
Instance details Defined in Data.Strict.These Methods pure :: a0 -> These a a0 Source # (<>) :: These a (a0 -> b) -> These a a0 -> These a b Source # liftA2 :: (a0 -> b -> c) -> These a a0 -> These a b -> These a c Source # (>) :: These a a0 -> These a b -> These a b Source # (<*) :: These a a0 -> These a b -> These a a0 Source #
( Functor m, Monad m) => Applicative ( MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods pure :: a -> MaybeT m a Source # (<>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b Source # liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c Source # (>) :: MaybeT m a -> MaybeT m b -> MaybeT m b Source # (<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a Source #
Applicative f => Applicative ( Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Rec1 f a Source # (<>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b Source # liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c Source # (>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a Source #
( 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) Source # (<>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0) Source # liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c) Source # (>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) Source # (<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0) Source #
Arrow a => Applicative ( WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 Source # (<>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source # (>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source #
Applicative m => Applicative ( Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> Kleisli m a a0 Source # (<>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b Source # liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c Source # (>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b Source # (<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0 Source #
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 Source # (<>) :: Const m (a -> b) -> Const m a -> Const m b Source # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c Source # (>) :: Const m a -> Const m b -> Const m b Source # (<*) :: Const m a -> Const m b -> Const m a Source #
Applicative f => Applicative ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Ap f a Source # (<>) :: Ap f (a -> b) -> Ap f a -> Ap f b Source # liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c Source # (>) :: Ap f a -> Ap f b -> Ap f b Source # (<*) :: Ap f a -> Ap f b -> Ap f a Source #
Applicative f => Applicative ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Alt f a Source # (<>) :: Alt f (a -> b) -> Alt f a -> Alt f b Source # liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c Source # (>) :: Alt f a -> Alt f b -> Alt f b Source # (<*) :: Alt f a -> Alt f b -> Alt f a Source #
Applicative m => Applicative ( IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods pure :: a -> IdentityT m a Source # (<>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b Source # liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c Source # (>) :: IdentityT m a -> IdentityT m b -> IdentityT m b Source # (<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a Source #
( 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 Source # (<>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c Source # (>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b Source # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a Source #
( Functor m, Monad m) => Applicative ( ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods pure :: a -> ErrorT e m a Source # (<>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b Source # liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c Source # (>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b Source # (<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a Source #
( Functor m, Monad m) => Applicative ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods pure :: a -> ExceptT e m a Source # (<>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b Source # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c Source # (>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b Source # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a Source #
Applicative m => Applicative ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods pure :: a -> ReaderT r m a Source # (<>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b Source # liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c Source # (>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b Source # (<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a Source #
( Functor m, Monad m) => Applicative ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods pure :: a -> StateT s m a Source # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c Source # (>) :: StateT s m a -> StateT s m b -> StateT s m b Source # (<*) :: StateT s m a -> StateT s m b -> StateT s m a Source #
( Functor m, Monad m) => Applicative ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods pure :: a -> StateT s m a Source # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c Source # (>) :: StateT s m a -> StateT s m b -> StateT s m b Source # (<*) :: StateT s m a -> StateT s m b -> StateT s m a Source #
( Monoid w, Applicative m) => Applicative ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods pure :: a -> WriterT w m a Source # (<>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b Source # liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c Source # (>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source # (<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a Source #
( Monoid w, Applicative m) => Applicative ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods pure :: a -> WriterT w m a Source # (<>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b Source # liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c Source # (>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source # (<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a Source #
Applicative ( Tagged s)
Instance details Defined in Data.Tagged Methods pure :: a -> Tagged s a Source # (<>) :: Tagged s (a -> b) -> Tagged s a -> Tagged s b Source # liftA2 :: (a -> b -> c) -> Tagged s a -> Tagged s b -> Tagged s c Source # (>) :: Tagged s a -> Tagged s b -> Tagged s b Source # (<*) :: Tagged s a -> Tagged s b -> Tagged s a Source #
Applicative ((->) r :: Type -> Type )	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> r -> a Source # (<>) :: (r -> (a -> b)) -> (r -> a) -> r -> b Source # liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c Source # (>) :: (r -> a) -> (r -> b) -> r -> b Source # (<*) :: (r -> a) -> (r -> b) -> r -> a Source #
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 Source # (<>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b Source # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 Source # (>) :: K1 i c a -> K1 i c b -> K1 i c b Source # (<*) :: K1 i c a -> K1 i c b -> K1 i c a Source #
( 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 Source # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b Source # liftA2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c Source # (>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # (<) :: (f :: g) a -> (f :: g) b -> (f :: g) a Source #
( 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) Source # (<>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) Source # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) Source # (>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) Source # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) Source #
( Applicative f, Applicative g) => Applicative ( Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods pure :: a -> Product f g a Source # (<>) :: Product f g (a -> b) -> Product f g a -> Product f g b Source # liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c Source # (>) :: Product f g a -> Product f g b -> Product f g b Source # (<*) :: Product f g a -> Product f g b -> Product f g a Source #
( 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 Source # (<>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c Source # (>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b Source # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a Source #
( 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 Source # (<>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c Source # (>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b Source # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a Source #
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 Source # (<>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b Source # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 Source # (>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source # (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a Source #
( 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 Source # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c Source # (>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b Source # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a Source #
( Applicative f, Applicative g) => Applicative ( Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a Source # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b Source # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c Source # (>) :: Compose f g a -> Compose f g b -> Compose f g b Source # (<*) :: Compose f g a -> Compose f g b -> Compose f g a Source #
( 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 Source # (<>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c Source # (>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b Source # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a Source #
( Monoid w, Functor m, Monad m) => Applicative ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods pure :: a -> RWST r w s m a Source # (<>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b Source # liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c Source # (>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source # (<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a Source #
( Monoid w, Functor m, Monad m) => Applicative ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods pure :: a -> RWST r w s m a Source # (<>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b Source # liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c Source # (>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source # (<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a Source #

class Foldable (t :: Type -> Type ) where Source #

Data structures that can be folded.

For example, given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Foldable Tree where
   foldMap f Empty = mempty
   foldMap f (Leaf x) = f x
   foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr :

instance Foldable Tree where
   foldr f z Empty = z
   foldr f z (Leaf x) = f x z
   foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

Foldable instances are expected to satisfy the following laws:

foldr f z t = appEndo (foldMap (Endo . f) t ) z

foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z

fold = foldMap id

length = getSum . foldMap (Sum . const  1)

sum , product , maximum , and minimum should all be essentially equivalent to foldMap forms, such as

sum = getSum . foldMap Sum

but may be less defined.

If the type is also a Functor instance, it should satisfy

foldMap f = fold . fmap f

which implies that

foldMap f . fmap g = foldMap (f . g)

Minimal complete definition

foldMap | foldr

Methods

fold :: Monoid m => t m -> m Source #

Combine the elements of a structure using a monoid.

foldMap :: Monoid m => (a -> m) -> t a -> m Source #

Map each element of the structure to a monoid, and combine the results.

foldr :: (a -> b -> b) -> b -> t a -> b Source #

Right-associative fold of a structure.

In the case of lists, foldr , when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, foldr can produce a terminating expression from an infinite list.

For a general Foldable structure this should be semantically identical to,

foldr f z = foldr f z . toList

foldr' :: (a -> b -> b) -> b -> t a -> b Source #

Right-associative fold of a structure, but with strict application of the operator.

Since: base-4.6.0.0

foldl :: (b -> a -> b) -> b -> t a -> b Source #

Left-associative fold of a structure.

In the case of lists, foldl , when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:

foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

Note that to produce the outermost application of the operator the entire input list must be traversed. This means that foldl' will diverge if given an infinite list.

Also note that if you want an efficient left-fold, you probably want to use foldl' instead of foldl . The reason for this is that latter does not force the "inner" results (e.g. z `f` x1 in the above example) before applying them to the operator (e.g. to (`f` x2) ). This results in a thunk chain $\mathcal{O}(n)$ elements long, which then must be evaluated from the outside-in.

For a general Foldable structure this should be semantically identical to,

foldl f z = foldl f z . toList

foldl' :: (b -> a -> b) -> b -> t a -> b Source #

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g. length ).

For a general Foldable structure this should be semantically identical to,

foldl' f z = foldl' f z . toList

Since: base-4.6.0.0

toList :: t a -> [a] Source #

List of elements of a structure, from left to right.

Since: base-4.8.0.0

null :: t a -> Bool Source #

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

Since: base-4.8.0.0

elem :: Eq a => a -> t a -> Bool infix 4 Source #

Does the element occur in the structure?

Since: base-4.8.0.0

maximum :: Ord a => t a -> a Source #

The largest element of a non-empty structure.

Since: base-4.8.0.0

minimum :: Ord a => t a -> a Source #

The least element of a non-empty structure.

Since: base-4.8.0.0

Instances

Instances details

Foldable []	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => [m] -> m Source # foldMap :: Monoid m => (a -> m) -> [a] -> m Source # foldMap' :: Monoid m => (a -> m) -> [a] -> m Source # foldr :: (a -> b -> b) -> b -> [a] -> b Source # foldr' :: (a -> b -> b) -> b -> [a] -> b Source # foldl :: (b -> a -> b) -> b -> [a] -> b Source # foldl' :: (b -> a -> b) -> b -> [a] -> b Source # foldr1 :: (a -> a -> a) -> [a] -> a Source # foldl1 :: (a -> a -> a) -> [a] -> a Source # toList :: [a] -> [a] Source # null :: [a] -> Bool Source # length :: [a] -> Int Source # elem :: Eq a => a -> [a] -> Bool Source # maximum :: Ord a => [a] -> a Source # minimum :: Ord a => [a] -> a Source # sum :: Num a => [a] -> a Source # product :: Num a => [a] -> a Source #
Foldable Maybe	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m Source # foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m Source # foldr :: (a -> b -> b) -> b -> Maybe a -> b Source # foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source # foldl :: (b -> a -> b) -> b -> Maybe a -> b Source # foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source # foldr1 :: (a -> a -> a) -> Maybe a -> a Source # foldl1 :: (a -> a -> a) -> Maybe a -> a Source # toList :: Maybe a -> [a] Source # null :: Maybe a -> Bool Source # length :: Maybe a -> Int Source # elem :: Eq a => a -> Maybe a -> Bool Source # maximum :: Ord a => Maybe a -> a Source # minimum :: Ord a => Maybe a -> a Source # sum :: Num a => Maybe a -> a Source # product :: Num a => Maybe a -> a Source #
Foldable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m Source # foldMap :: Monoid m => (a -> m) -> Par1 a -> m Source # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m Source # foldr :: (a -> b -> b) -> b -> Par1 a -> b Source # foldr' :: (a -> b -> b) -> b -> Par1 a -> b Source # foldl :: (b -> a -> b) -> b -> Par1 a -> b Source # foldl' :: (b -> a -> b) -> b -> Par1 a -> b Source # foldr1 :: (a -> a -> a) -> Par1 a -> a Source # foldl1 :: (a -> a -> a) -> Par1 a -> a Source # toList :: Par1 a -> [a] Source # null :: Par1 a -> Bool Source # length :: Par1 a -> Int Source # elem :: Eq a => a -> Par1 a -> Bool Source # maximum :: Ord a => Par1 a -> a Source # minimum :: Ord a => Par1 a -> a Source # sum :: Num a => Par1 a -> a Source # product :: Num a => Par1 a -> a Source #
Foldable Solo
Instance details Defined in Data.Tuple.Solo Methods fold :: Monoid m => Solo m -> m Source # foldMap :: Monoid m => (a -> m) -> Solo a -> m Source # foldMap' :: Monoid m => (a -> m) -> Solo a -> m Source # foldr :: (a -> b -> b) -> b -> Solo a -> b Source # foldr' :: (a -> b -> b) -> b -> Solo a -> b Source # foldl :: (b -> a -> b) -> b -> Solo a -> b Source # foldl' :: (b -> a -> b) -> b -> Solo a -> b Source # foldr1 :: (a -> a -> a) -> Solo a -> a Source # foldl1 :: (a -> a -> a) -> Solo a -> a Source # toList :: Solo a -> [a] Source # null :: Solo a -> Bool Source # length :: Solo a -> Int Source # elem :: Eq a => a -> Solo a -> Bool Source # maximum :: Ord a => Solo a -> a Source # minimum :: Ord a => Solo a -> a Source # sum :: Num a => Solo a -> a Source # product :: Num a => Solo a -> a Source #
Foldable IResult
Instance details Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => IResult m -> m Source # foldMap :: Monoid m => (a -> m) -> IResult a -> m Source # foldMap' :: Monoid m => (a -> m) -> IResult a -> m Source # foldr :: (a -> b -> b) -> b -> IResult a -> b Source # foldr' :: (a -> b -> b) -> b -> IResult a -> b Source # foldl :: (b -> a -> b) -> b -> IResult a -> b Source # foldl' :: (b -> a -> b) -> b -> IResult a -> b Source # foldr1 :: (a -> a -> a) -> IResult a -> a Source # foldl1 :: (a -> a -> a) -> IResult a -> a Source # toList :: IResult a -> [a] Source # null :: IResult a -> Bool Source # length :: IResult a -> Int Source # elem :: Eq a => a -> IResult a -> Bool Source # maximum :: Ord a => IResult a -> a Source # minimum :: Ord a => IResult a -> a Source # sum :: Num a => IResult a -> a Source # product :: Num a => IResult a -> a Source #
Foldable Result
Instance details Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => Result m -> m Source # foldMap :: Monoid m => (a -> m) -> Result a -> m Source # foldMap' :: Monoid m => (a -> m) -> Result a -> m Source # foldr :: (a -> b -> b) -> b -> Result a -> b Source # foldr' :: (a -> b -> b) -> b -> Result a -> b Source # foldl :: (b -> a -> b) -> b -> Result a -> b Source # foldl' :: (b -> a -> b) -> b -> Result a -> b Source # foldr1 :: (a -> a -> a) -> Result a -> a Source # foldl1 :: (a -> a -> a) -> Result a -> a Source # toList :: Result a -> [a] Source # null :: Result a -> Bool Source # length :: Result a -> Int Source # elem :: Eq a => a -> Result a -> Bool Source # maximum :: Ord a => Result a -> a Source # minimum :: Ord a => Result a -> a Source # sum :: Num a => Result a -> a Source # product :: Num a => Result a -> a Source #
Foldable KeyMap
Instance details Defined in Data.Aeson.KeyMap Methods fold :: Monoid m => KeyMap m -> m Source # foldMap :: Monoid m => (a -> m) -> KeyMap a -> m Source # foldMap' :: Monoid m => (a -> m) -> KeyMap a -> m Source # foldr :: (a -> b -> b) -> b -> KeyMap a -> b Source # foldr' :: (a -> b -> b) -> b -> KeyMap a -> b Source # foldl :: (b -> a -> b) -> b -> KeyMap a -> b Source # foldl' :: (b -> a -> b) -> b -> KeyMap a -> b Source # foldr1 :: (a -> a -> a) -> KeyMap a -> a Source # foldl1 :: (a -> a -> a) -> KeyMap a -> a Source # toList :: KeyMap a -> [a] Source # null :: KeyMap a -> Bool Source # length :: KeyMap a -> Int Source # elem :: Eq a => a -> KeyMap a -> Bool Source # maximum :: Ord a => KeyMap a -> a Source # minimum :: Ord a => KeyMap a -> a Source # sum :: Num a => KeyMap a -> a Source # product :: Num a => KeyMap a -> a Source #
Foldable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m Source # foldMap :: Monoid m => (a -> m) -> Complex a -> m Source # foldMap' :: Monoid m => (a -> m) -> Complex a -> m Source # foldr :: (a -> b -> b) -> b -> Complex a -> b Source # foldr' :: (a -> b -> b) -> b -> Complex a -> b Source # foldl :: (b -> a -> b) -> b -> Complex a -> b Source # foldl' :: (b -> a -> b) -> b -> Complex a -> b Source # foldr1 :: (a -> a -> a) -> Complex a -> a Source # foldl1 :: (a -> a -> a) -> Complex a -> a Source # toList :: Complex a -> [a] Source # null :: Complex a -> Bool Source # length :: Complex a -> Int Source # elem :: Eq a => a -> Complex a -> Bool Source # maximum :: Ord a => Complex a -> a Source # minimum :: Ord a => Complex a -> a Source # sum :: Num a => Complex a -> a Source # product :: Num a => Complex a -> a Source #
Foldable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m Source # foldMap :: Monoid m => (a -> m) -> Min a -> m Source # foldMap' :: Monoid m => (a -> m) -> Min a -> m Source # foldr :: (a -> b -> b) -> b -> Min a -> b Source # foldr' :: (a -> b -> b) -> b -> Min a -> b Source # foldl :: (b -> a -> b) -> b -> Min a -> b Source # foldl' :: (b -> a -> b) -> b -> Min a -> b Source # foldr1 :: (a -> a -> a) -> Min a -> a Source # foldl1 :: (a -> a -> a) -> Min a -> a Source # toList :: Min a -> [a] Source # null :: Min a -> Bool Source # length :: Min a -> Int Source # elem :: Eq a => a -> Min a -> Bool Source # maximum :: Ord a => Min a -> a Source # minimum :: Ord a => Min a -> a Source # sum :: Num a => Min a -> a Source # product :: Num a => Min a -> a Source #
Foldable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m Source # foldMap :: Monoid m => (a -> m) -> Max a -> m Source # foldMap' :: Monoid m => (a -> m) -> Max a -> m Source # foldr :: (a -> b -> b) -> b -> Max a -> b Source # foldr' :: (a -> b -> b) -> b -> Max a -> b Source # foldl :: (b -> a -> b) -> b -> Max a -> b Source # foldl' :: (b -> a -> b) -> b -> Max a -> b Source # foldr1 :: (a -> a -> a) -> Max a -> a Source # foldl1 :: (a -> a -> a) -> Max a -> a Source # toList :: Max a -> [a] Source # null :: Max a -> Bool Source # length :: Max a -> Int Source # elem :: Eq a => a -> Max a -> Bool Source # maximum :: Ord a => Max a -> a Source # minimum :: Ord a => Max a -> a Source # sum :: Num a => Max a -> a Source # product :: Num a => Max a -> a Source #
Foldable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m Source # foldMap :: Monoid m => (a -> m) -> First a -> m Source # foldMap' :: Monoid m => (a -> m) -> First a -> m Source # foldr :: (a -> b -> b) -> b -> First a -> b Source # foldr' :: (a -> b -> b) -> b -> First a -> b Source # foldl :: (b -> a -> b) -> b -> First a -> b Source # foldl' :: (b -> a -> b) -> b -> First a -> b Source # foldr1 :: (a -> a -> a) -> First a -> a Source # foldl1 :: (a -> a -> a) -> First a -> a Source # toList :: First a -> [a] Source # null :: First a -> Bool Source # length :: First a -> Int Source # elem :: Eq a => a -> First a -> Bool Source # maximum :: Ord a => First a -> a Source # minimum :: Ord a => First a -> a Source # sum :: Num a => First a -> a Source # product :: Num a => First a -> a Source #
Foldable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m Source # foldMap :: Monoid m => (a -> m) -> Last a -> m Source # foldMap' :: Monoid m => (a -> m) -> Last a -> m Source # foldr :: (a -> b -> b) -> b -> Last a -> b Source # foldr' :: (a -> b -> b) -> b -> Last a -> b Source # foldl :: (b -> a -> b) -> b -> Last a -> b Source # foldl' :: (b -> a -> b) -> b -> Last a -> b Source # foldr1 :: (a -> a -> a) -> Last a -> a Source # foldl1 :: (a -> a -> a) -> Last a -> a Source # toList :: Last a -> [a] Source # null :: Last a -> Bool Source # length :: Last a -> Int Source # elem :: Eq a => a -> Last a -> Bool Source # maximum :: Ord a => Last a -> a Source # minimum :: Ord a => Last a -> a Source # sum :: Num a => Last a -> a Source # product :: Num a => Last a -> a Source #
Foldable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m Source # foldMap :: Monoid m => (a -> m) -> Option a -> m Source # foldMap' :: Monoid m => (a -> m) -> Option a -> m Source # foldr :: (a -> b -> b) -> b -> Option a -> b Source # foldr' :: (a -> b -> b) -> b -> Option a -> b Source # foldl :: (b -> a -> b) -> b -> Option a -> b Source # foldl' :: (b -> a -> b) -> b -> Option a -> b Source # foldr1 :: (a -> a -> a) -> Option a -> a Source # foldl1 :: (a -> a -> a) -> Option a -> a Source # toList :: Option a -> [a] Source # null :: Option a -> Bool Source # length :: Option a -> Int Source # elem :: Eq a => a -> Option a -> Bool Source # maximum :: Ord a => Option a -> a Source # minimum :: Ord a => Option a -> a Source # sum :: Num a => Option a -> a Source # product :: Num a => Option a -> a Source #
Foldable ZipList	Since: base-4.9.0.0
Instance details Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m Source # foldMap :: Monoid m => (a -> m) -> ZipList a -> m Source # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m Source # foldr :: (a -> b -> b) -> b -> ZipList a -> b Source # foldr' :: (a -> b -> b) -> b -> ZipList a -> b Source # foldl :: (b -> a -> b) -> b -> ZipList a -> b Source # foldl' :: (b -> a -> b) -> b -> ZipList a -> b Source # foldr1 :: (a -> a -> a) -> ZipList a -> a Source # foldl1 :: (a -> a -> a) -> ZipList a -> a Source # toList :: ZipList a -> [a] Source # null :: ZipList a -> Bool Source # length :: ZipList a -> Int Source # elem :: Eq a => a -> ZipList a -> Bool Source # maximum :: Ord a => ZipList a -> a Source # minimum :: Ord a => ZipList a -> a Source # sum :: Num a => ZipList a -> a Source # product :: Num a => ZipList a -> a Source #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m Source # foldMap :: Monoid m => (a -> m) -> Identity a -> m Source # foldMap' :: Monoid m => (a -> m) -> Identity a -> m Source # foldr :: (a -> b -> b) -> b -> Identity a -> b Source # foldr' :: (a -> b -> b) -> b -> Identity a -> b Source # foldl :: (b -> a -> b) -> b -> Identity a -> b Source # foldl' :: (b -> a -> b) -> b -> Identity a -> b Source # foldr1 :: (a -> a -> a) -> Identity a -> a Source # foldl1 :: (a -> a -> a) -> Identity a -> a Source # toList :: Identity a -> [a] Source # null :: Identity a -> Bool Source # length :: Identity a -> Int Source # elem :: Eq a => a -> Identity a -> Bool Source # maximum :: Ord a => Identity a -> a Source # minimum :: Ord a => Identity a -> a Source # sum :: Num a => Identity a -> a Source # product :: Num a => Identity a -> a Source #
Foldable First	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => First m -> m Source # foldMap :: Monoid m => (a -> m) -> First a -> m Source # foldMap' :: Monoid m => (a -> m) -> First a -> m Source # foldr :: (a -> b -> b) -> b -> First a -> b Source # foldr' :: (a -> b -> b) -> b -> First a -> b Source # foldl :: (b -> a -> b) -> b -> First a -> b Source # foldl' :: (b -> a -> b) -> b -> First a -> b Source # foldr1 :: (a -> a -> a) -> First a -> a Source # foldl1 :: (a -> a -> a) -> First a -> a Source # toList :: First a -> [a] Source # null :: First a -> Bool Source # length :: First a -> Int Source # elem :: Eq a => a -> First a -> Bool Source # maximum :: Ord a => First a -> a Source # minimum :: Ord a => First a -> a Source # sum :: Num a => First a -> a Source # product :: Num a => First a -> a Source #
Foldable Last	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m Source # foldMap :: Monoid m => (a -> m) -> Last a -> m Source # foldMap' :: Monoid m => (a -> m) -> Last a -> m Source # foldr :: (a -> b -> b) -> b -> Last a -> b Source # foldr' :: (a -> b -> b) -> b -> Last a -> b Source # foldl :: (b -> a -> b) -> b -> Last a -> b Source # foldl' :: (b -> a -> b) -> b -> Last a -> b Source # foldr1 :: (a -> a -> a) -> Last a -> a Source # foldl1 :: (a -> a -> a) -> Last a -> a Source # toList :: Last a -> [a] Source # null :: Last a -> Bool Source # length :: Last a -> Int Source # elem :: Eq a => a -> Last a -> Bool Source # maximum :: Ord a => Last a -> a Source # minimum :: Ord a => Last a -> a Source # sum :: Num a => Last a -> a Source # product :: Num a => Last a -> a Source #
Foldable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m Source # foldMap :: Monoid m => (a -> m) -> Dual a -> m Source # foldMap' :: Monoid m => (a -> m) -> Dual a -> m Source # foldr :: (a -> b -> b) -> b -> Dual a -> b Source # foldr' :: (a -> b -> b) -> b -> Dual a -> b Source # foldl :: (b -> a -> b) -> b -> Dual a -> b Source # foldl' :: (b -> a -> b) -> b -> Dual a -> b Source # foldr1 :: (a -> a -> a) -> Dual a -> a Source # foldl1 :: (a -> a -> a) -> Dual a -> a Source # toList :: Dual a -> [a] Source # null :: Dual a -> Bool Source # length :: Dual a -> Int Source # elem :: Eq a => a -> Dual a -> Bool Source # maximum :: Ord a => Dual a -> a Source # minimum :: Ord a => Dual a -> a Source # sum :: Num a => Dual a -> a Source # product :: Num a => Dual a -> a Source #
Foldable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m Source # foldMap :: Monoid m => (a -> m) -> Sum a -> m Source # foldMap' :: Monoid m => (a -> m) -> Sum a -> m Source # foldr :: (a -> b -> b) -> b -> Sum a -> b Source # foldr' :: (a -> b -> b) -> b -> Sum a -> b Source # foldl :: (b -> a -> b) -> b -> Sum a -> b Source # foldl' :: (b -> a -> b) -> b -> Sum a -> b Source # foldr1 :: (a -> a -> a) -> Sum a -> a Source # foldl1 :: (a -> a -> a) -> Sum a -> a Source # toList :: Sum a -> [a] Source # null :: Sum a -> Bool Source # length :: Sum a -> Int Source # elem :: Eq a => a -> Sum a -> Bool Source # maximum :: Ord a => Sum a -> a Source # minimum :: Ord a => Sum a -> a Source # sum :: Num a => Sum a -> a Source # product :: Num a => Sum a -> a Source #
Foldable Product	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m Source # foldMap :: Monoid m => (a -> m) -> Product a -> m Source # foldMap' :: Monoid m => (a -> m) -> Product a -> m Source # foldr :: (a -> b -> b) -> b -> Product a -> b Source # foldr' :: (a -> b -> b) -> b -> Product a -> b Source # foldl :: (b -> a -> b) -> b -> Product a -> b Source # foldl' :: (b -> a -> b) -> b -> Product a -> b Source # foldr1 :: (a -> a -> a) -> Product a -> a Source # foldl1 :: (a -> a -> a) -> Product a -> a Source # toList :: Product a -> [a] Source # null :: Product a -> Bool Source # length :: Product a -> Int Source # elem :: Eq a => a -> Product a -> Bool Source # maximum :: Ord a => Product a -> a Source # minimum :: Ord a => Product a -> a Source # sum :: Num a => Product a -> a Source # product :: Num a => Product a -> a Source #
Foldable Down	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m Source # foldMap :: Monoid m => (a -> m) -> Down a -> m Source # foldMap' :: Monoid m => (a -> m) -> Down a -> m Source # foldr :: (a -> b -> b) -> b -> Down a -> b Source # foldr' :: (a -> b -> b) -> b -> Down a -> b Source # foldl :: (b -> a -> b) -> b -> Down a -> b Source # foldl' :: (b -> a -> b) -> b -> Down a -> b Source # foldr1 :: (a -> a -> a) -> Down a -> a Source # foldl1 :: (a -> a -> a) -> Down a -> a Source # toList :: Down a -> [a] Source # null :: Down a -> Bool Source # length :: Down a -> Int Source # elem :: Eq a => a -> Down a -> Bool Source # maximum :: Ord a => Down a -> a Source # minimum :: Ord a => Down a -> a Source # sum :: Num a => Down a -> a Source # product :: Num a => Down a -> a Source #
Foldable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m Source # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m Source # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m Source # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b Source # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b Source # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b Source # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b Source # foldr1 :: (a -> a -> a) -> NonEmpty a -> a Source # foldl1 :: (a -> a -> a) -> NonEmpty a -> a Source # toList :: NonEmpty a -> [a] Source # null :: NonEmpty a -> Bool Source # length :: NonEmpty a -> Int Source # elem :: Eq a => a -> NonEmpty a -> Bool Source # maximum :: Ord a => NonEmpty a -> a Source # minimum :: Ord a => NonEmpty a -> a Source # sum :: Num a => NonEmpty a -> a Source # product :: Num a => NonEmpty a -> a Source #
Foldable IntMap	Folds in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m Source # foldMap :: Monoid m => (a -> m) -> IntMap a -> m Source # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m Source # foldr :: (a -> b -> b) -> b -> IntMap a -> b Source # foldr' :: (a -> b -> b) -> b -> IntMap a -> b Source # foldl :: (b -> a -> b) -> b -> IntMap a -> b Source # foldl' :: (b -> a -> b) -> b -> IntMap a -> b Source # foldr1 :: (a -> a -> a) -> IntMap a -> a Source # foldl1 :: (a -> a -> a) -> IntMap a -> a Source # toList :: IntMap a -> [a] Source # null :: IntMap a -> Bool Source # length :: IntMap a -> Int Source # elem :: Eq a => a -> IntMap a -> Bool Source # maximum :: Ord a => IntMap a -> a Source # minimum :: Ord a => IntMap a -> a Source # sum :: Num a => IntMap a -> a Source # product :: Num a => IntMap a -> a Source #
Foldable Tree
Instance details Defined in Data.Tree Methods fold :: Monoid m => Tree m -> m Source # foldMap :: Monoid m => (a -> m) -> Tree a -> m Source # foldMap' :: Monoid m => (a -> m) -> Tree a -> m Source # foldr :: (a -> b -> b) -> b -> Tree a -> b Source # foldr' :: (a -> b -> b) -> b -> Tree a -> b Source # foldl :: (b -> a -> b) -> b -> Tree a -> b Source # foldl' :: (b -> a -> b) -> b -> Tree a -> b Source # foldr1 :: (a -> a -> a) -> Tree a -> a Source # foldl1 :: (a -> a -> a) -> Tree a -> a Source # toList :: Tree a -> [a] Source # null :: Tree a -> Bool Source # length :: Tree a -> Int Source # elem :: Eq a => a -> Tree a -> Bool Source # maximum :: Ord a => Tree a -> a Source # minimum :: Ord a => Tree a -> a Source # sum :: Num a => Tree a -> a Source # product :: Num a => Tree a -> a Source #
Foldable Seq
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m Source # foldMap :: Monoid m => (a -> m) -> Seq a -> m Source # foldMap' :: Monoid m => (a -> m) -> Seq a -> m Source # foldr :: (a -> b -> b) -> b -> Seq a -> b Source # foldr' :: (a -> b -> b) -> b -> Seq a -> b Source # foldl :: (b -> a -> b) -> b -> Seq a -> b Source # foldl' :: (b -> a -> b) -> b -> Seq a -> b Source # foldr1 :: (a -> a -> a) -> Seq a -> a Source # foldl1 :: (a -> a -> a) -> Seq a -> a Source # toList :: Seq a -> [a] Source # null :: Seq a -> Bool Source # length :: Seq a -> Int Source # elem :: Eq a => a -> Seq a -> Bool Source # maximum :: Ord a => Seq a -> a Source # minimum :: Ord a => Seq a -> a Source # sum :: Num a => Seq a -> a Source # product :: Num a => Seq a -> a Source #
Foldable FingerTree
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m Source # foldMap :: Monoid m => (a -> m) -> FingerTree a -> m Source # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m Source # foldr :: (a -> b -> b) -> b -> FingerTree a -> b Source # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b Source # foldl :: (b -> a -> b) -> b -> FingerTree a -> b Source # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b Source # foldr1 :: (a -> a -> a) -> FingerTree a -> a Source # foldl1 :: (a -> a -> a) -> FingerTree a -> a Source # toList :: FingerTree a -> [a] Source # null :: FingerTree a -> Bool Source # length :: FingerTree a -> Int Source # elem :: Eq a => a -> FingerTree a -> Bool Source # maximum :: Ord a => FingerTree a -> a Source # minimum :: Ord a => FingerTree a -> a Source # sum :: Num a => FingerTree a -> a Source # product :: Num a => FingerTree a -> a Source #
Foldable Digit
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m Source # foldMap :: Monoid m => (a -> m) -> Digit a -> m Source # foldMap' :: Monoid m => (a -> m) -> Digit a -> m Source # foldr :: (a -> b -> b) -> b -> Digit a -> b Source # foldr' :: (a -> b -> b) -> b -> Digit a -> b Source # foldl :: (b -> a -> b) -> b -> Digit a -> b Source # foldl' :: (b -> a -> b) -> b -> Digit a -> b Source # foldr1 :: (a -> a -> a) -> Digit a -> a Source # foldl1 :: (a -> a -> a) -> Digit a -> a Source # toList :: Digit a -> [a] Source # null :: Digit a -> Bool Source # length :: Digit a -> Int Source # elem :: Eq a => a -> Digit a -> Bool Source # maximum :: Ord a => Digit a -> a Source # minimum :: Ord a => Digit a -> a Source # sum :: Num a => Digit a -> a Source # product :: Num a => Digit a -> a Source #
Foldable Node
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m Source # foldMap :: Monoid m => (a -> m) -> Node a -> m Source # foldMap' :: Monoid m => (a -> m) -> Node a -> m Source # foldr :: (a -> b -> b) -> b -> Node a -> b Source # foldr' :: (a -> b -> b) -> b -> Node a -> b Source # foldl :: (b -> a -> b) -> b -> Node a -> b Source # foldl' :: (b -> a -> b) -> b -> Node a -> b Source # foldr1 :: (a -> a -> a) -> Node a -> a Source # foldl1 :: (a -> a -> a) -> Node a -> a Source # toList :: Node a -> [a] Source # null :: Node a -> Bool Source # length :: Node a -> Int Source # elem :: Eq a => a -> Node a -> Bool Source # maximum :: Ord a => Node a -> a Source # minimum :: Ord a => Node a -> a Source # sum :: Num a => Node a -> a Source # product :: Num a => Node a -> a Source #
Foldable Elem
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m Source # foldMap :: Monoid m => (a -> m) -> Elem a -> m Source # foldMap' :: Monoid m => (a -> m) -> Elem a -> m Source # foldr :: (a -> b -> b) -> b -> Elem a -> b Source # foldr' :: (a -> b -> b) -> b -> Elem a -> b Source # foldl :: (b -> a -> b) -> b -> Elem a -> b Source # foldl' :: (b -> a -> b) -> b -> Elem a -> b Source # foldr1 :: (a -> a -> a) -> Elem a -> a Source # foldl1 :: (a -> a -> a) -> Elem a -> a Source # toList :: Elem a -> [a] Source # null :: Elem a -> Bool Source # length :: Elem a -> Int Source # elem :: Eq a => a -> Elem a -> Bool Source # maximum :: Ord a => Elem a -> a Source # minimum :: Ord a => Elem a -> a Source # sum :: Num a => Elem a -> a Source # product :: Num a => Elem a -> a Source #
Foldable ViewL
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m Source # foldMap :: Monoid m => (a -> m) -> ViewL a -> m Source # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m Source # foldr :: (a -> b -> b) -> b -> ViewL a -> b Source # foldr' :: (a -> b -> b) -> b -> ViewL a -> b Source # foldl :: (b -> a -> b) -> b -> ViewL a -> b Source # foldl' :: (b -> a -> b) -> b -> ViewL a -> b Source # foldr1 :: (a -> a -> a) -> ViewL a -> a Source # foldl1 :: (a -> a -> a) -> ViewL a -> a Source # toList :: ViewL a -> [a] Source # null :: ViewL a -> Bool Source # length :: ViewL a -> Int Source # elem :: Eq a => a -> ViewL a -> Bool Source # maximum :: Ord a => ViewL a -> a Source # minimum :: Ord a => ViewL a -> a Source # sum :: Num a => ViewL a -> a Source # product :: Num a => ViewL a -> a Source #
Foldable ViewR
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m Source # foldMap :: Monoid m => (a -> m) -> ViewR a -> m Source # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m Source # foldr :: (a -> b -> b) -> b -> ViewR a -> b Source # foldr' :: (a -> b -> b) -> b -> ViewR a -> b Source # foldl :: (b -> a -> b) -> b -> ViewR a -> b Source # foldl' :: (b -> a -> b) -> b -> ViewR a -> b Source # foldr1 :: (a -> a -> a) -> ViewR a -> a Source # foldl1 :: (a -> a -> a) -> ViewR a -> a Source # toList :: ViewR a -> [a] Source # null :: ViewR a -> Bool Source # length :: ViewR a -> Int Source # elem :: Eq a => a -> ViewR a -> Bool Source # maximum :: Ord a => ViewR a -> a Source # minimum :: Ord a => ViewR a -> a Source # sum :: Num a => ViewR a -> a Source # product :: Num a => ViewR a -> a Source #
Foldable Set	Folds in order of increasing key.
Instance details Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m Source # foldMap :: Monoid m => (a -> m) -> Set a -> m Source # foldMap' :: Monoid m => (a -> m) -> Set a -> m Source # foldr :: (a -> b -> b) -> b -> Set a -> b Source # foldr' :: (a -> b -> b) -> b -> Set a -> b Source # foldl :: (b -> a -> b) -> b -> Set a -> b Source # foldl' :: (b -> a -> b) -> b -> Set a -> b Source # foldr1 :: (a -> a -> a) -> Set a -> a Source # foldl1 :: (a -> a -> a) -> Set a -> a Source # toList :: Set a -> [a] Source # null :: Set a -> Bool Source # length :: Set a -> Int Source # elem :: Eq a => a -> Set a -> Bool Source # maximum :: Ord a => Set a -> a Source # minimum :: Ord a => Set a -> a Source # sum :: Num a => Set a -> a Source # product :: Num a => Set a -> a Source #
Foldable DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods fold :: Monoid m => DNonEmpty m -> m Source # foldMap :: Monoid m => (a -> m) -> DNonEmpty a -> m Source # foldMap' :: Monoid m => (a -> m) -> DNonEmpty a -> m Source # foldr :: (a -> b -> b) -> b -> DNonEmpty a -> b Source # foldr' :: (a -> b -> b) -> b -> DNonEmpty a -> b Source # foldl :: (b -> a -> b) -> b -> DNonEmpty a -> b Source # foldl' :: (b -> a -> b) -> b -> DNonEmpty a -> b Source # foldr1 :: (a -> a -> a) -> DNonEmpty a -> a Source # foldl1 :: (a -> a -> a) -> DNonEmpty a -> a Source # toList :: DNonEmpty a -> [a] Source # null :: DNonEmpty a -> Bool Source # length :: DNonEmpty a -> Int Source # elem :: Eq a => a -> DNonEmpty a -> Bool Source # maximum :: Ord a => DNonEmpty a -> a Source # minimum :: Ord a => DNonEmpty a -> a Source # sum :: Num a => DNonEmpty a -> a Source # product :: Num a => DNonEmpty a -> a Source #
Foldable DList
Instance details Defined in Data.DList.Internal Methods fold :: Monoid m => DList m -> m Source # foldMap :: Monoid m => (a -> m) -> DList a -> m Source # foldMap' :: Monoid m => (a -> m) -> DList a -> m Source # foldr :: (a -> b -> b) -> b -> DList a -> b Source # foldr' :: (a -> b -> b) -> b -> DList a -> b Source # foldl :: (b -> a -> b) -> b -> DList a -> b Source # foldl' :: (b -> a -> b) -> b -> DList a -> b Source # foldr1 :: (a -> a -> a) -> DList a -> a Source # foldl1 :: (a -> a -> a) -> DList a -> a Source # toList :: DList a -> [a] Source # null :: DList a -> Bool Source # length :: DList a -> Int Source # elem :: Eq a => a -> DList a -> Bool Source # maximum :: Ord a => DList a -> a Source # minimum :: Ord a => DList a -> a Source # sum :: Num a => DList a -> a Source # product :: Num a => DList a -> a Source #
Foldable GenClosure
Instance details Defined in GHC.Exts.Heap.Closures Methods fold :: Monoid m => GenClosure m -> m Source # foldMap :: Monoid m => (a -> m) -> GenClosure a -> m Source # foldMap' :: Monoid m => (a -> m) -> GenClosure a -> m Source # foldr :: (a -> b -> b) -> b -> GenClosure a -> b Source # foldr' :: (a -> b -> b) -> b -> GenClosure a -> b Source # foldl :: (b -> a -> b) -> b -> GenClosure a -> b Source # foldl' :: (b -> a -> b) -> b -> GenClosure a -> b Source # foldr1 :: (a -> a -> a) -> GenClosure a -> a Source # foldl1 :: (a -> a -> a) -> GenClosure a -> a Source # toList :: GenClosure a -> [a] Source # null :: GenClosure a -> Bool Source # length :: GenClosure a -> Int Source # elem :: Eq a => a -> GenClosure a -> Bool Source # maximum :: Ord a => GenClosure a -> a Source # minimum :: Ord a => GenClosure a -> a Source # sum :: Num a => GenClosure a -> a Source # product :: Num a => GenClosure a -> a Source #
Foldable Hashed
Instance details Defined in Data.Hashable.Class Methods fold :: Monoid m => Hashed m -> m Source # foldMap :: Monoid m => (a -> m) -> Hashed a -> m Source # foldMap' :: Monoid m => (a -> m) -> Hashed a -> m Source # foldr :: (a -> b -> b) -> b -> Hashed a -> b Source # foldr' :: (a -> b -> b) -> b -> Hashed a -> b Source # foldl :: (b -> a -> b) -> b -> Hashed a -> b Source # foldl' :: (b -> a -> b) -> b -> Hashed a -> b Source # foldr1 :: (a -> a -> a) -> Hashed a -> a Source # foldl1 :: (a -> a -> a) -> Hashed a -> a Source # toList :: Hashed a -> [a] Source # null :: Hashed a -> Bool Source # length :: Hashed a -> Int Source # elem :: Eq a => a -> Hashed a -> Bool Source # maximum :: Ord a => Hashed a -> a Source # minimum :: Ord a => Hashed a -> a Source # sum :: Num a => Hashed a -> a Source # product :: Num a => Hashed a -> a Source #
Foldable SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fold :: Monoid m => SmallArray m -> m Source # foldMap :: Monoid m => (a -> m) -> SmallArray a -> m Source # foldMap' :: Monoid m => (a -> m) -> SmallArray a -> m Source # foldr :: (a -> b -> b) -> b -> SmallArray a -> b Source # foldr' :: (a -> b -> b) -> b -> SmallArray a -> b Source # foldl :: (b -> a -> b) -> b -> SmallArray a -> b Source # foldl' :: (b -> a -> b) -> b -> SmallArray a -> b Source # foldr1 :: (a -> a -> a) -> SmallArray a -> a Source # foldl1 :: (a -> a -> a) -> SmallArray a -> a Source # toList :: SmallArray a -> [a] Source # null :: SmallArray a -> Bool Source # length :: SmallArray a -> Int Source # elem :: Eq a => a -> SmallArray a -> Bool Source # maximum :: Ord a => SmallArray a -> a Source # minimum :: Ord a => SmallArray a -> a Source # sum :: Num a => SmallArray a -> a Source # product :: Num a => SmallArray a -> a Source #
Foldable Array
Instance details Defined in Data.Primitive.Array Methods fold :: Monoid m => Array m -> m Source # foldMap :: Monoid m => (a -> m) -> Array a -> m Source # foldMap' :: Monoid m => (a -> m) -> Array a -> m Source # foldr :: (a -> b -> b) -> b -> Array a -> b Source # foldr' :: (a -> b -> b) -> b -> Array a -> b Source # foldl :: (b -> a -> b) -> b -> Array a -> b Source # foldl' :: (b -> a -> b) -> b -> Array a -> b Source # foldr1 :: (a -> a -> a) -> Array a -> a Source # foldl1 :: (a -> a -> a) -> Array a -> a Source # toList :: Array a -> [a] Source # null :: Array a -> Bool Source # length :: Array a -> Int Source # elem :: Eq a => a -> Array a -> Bool Source # maximum :: Ord a => Array a -> a Source # minimum :: Ord a => Array a -> a Source # sum :: Num a => Array a -> a Source # product :: Num a => Array a -> a Source #
Foldable Maybe
Instance details Defined in Data.Strict.Maybe Methods fold :: Monoid m => Maybe m -> m Source # foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m Source # foldr :: (a -> b -> b) -> b -> Maybe a -> b Source # foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source # foldl :: (b -> a -> b) -> b -> Maybe a -> b Source # foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source # foldr1 :: (a -> a -> a) -> Maybe a -> a Source # foldl1 :: (a -> a -> a) -> Maybe a -> a Source # toList :: Maybe a -> [a] Source # null :: Maybe a -> Bool Source # length :: Maybe a -> Int Source # elem :: Eq a => a -> Maybe a -> Bool Source # maximum :: Ord a => Maybe a -> a Source # minimum :: Ord a => Maybe a -> a Source # sum :: Num a => Maybe a -> a Source # product :: Num a => Maybe a -> a Source #
Foldable HashSet
Instance details Defined in Data.HashSet.Internal Methods fold :: Monoid m => HashSet m -> m Source # foldMap :: Monoid m => (a -> m) -> HashSet a -> m Source # foldMap' :: Monoid m => (a -> m) -> HashSet a -> m Source # foldr :: (a -> b -> b) -> b -> HashSet a -> b Source # foldr' :: (a -> b -> b) -> b -> HashSet a -> b Source # foldl :: (b -> a -> b) -> b -> HashSet a -> b Source # foldl' :: (b -> a -> b) -> b -> HashSet a -> b Source # foldr1 :: (a -> a -> a) -> HashSet a -> a Source # foldl1 :: (a -> a -> a) -> HashSet a -> a Source # toList :: HashSet a -> [a] Source # null :: HashSet a -> Bool Source # length :: HashSet a -> Int Source # elem :: Eq a => a -> HashSet a -> Bool Source # maximum :: Ord a => HashSet a -> a Source # minimum :: Ord a => HashSet a -> a Source # sum :: Num a => HashSet a -> a Source # product :: Num a => HashSet a -> a Source #
Foldable Vector
Instance details Defined in Data.Vector Methods fold :: Monoid m => Vector m -> m Source # foldMap :: Monoid m => (a -> m) -> Vector a -> m Source # foldMap' :: Monoid m => (a -> m) -> Vector a -> m Source # foldr :: (a -> b -> b) -> b -> Vector a -> b Source # foldr' :: (a -> b -> b) -> b -> Vector a -> b Source # foldl :: (b -> a -> b) -> b -> Vector a -> b Source # foldl' :: (b -> a -> b) -> b -> Vector a -> b Source # foldr1 :: (a -> a -> a) -> Vector a -> a Source # foldl1 :: (a -> a -> a) -> Vector a -> a Source # toList :: Vector a -> [a] Source # null :: Vector a -> Bool Source # length :: Vector a -> Int Source # elem :: Eq a => a -> Vector a -> Bool Source # maximum :: Ord a => Vector a -> a Source # minimum :: Ord a => Vector a -> a Source # sum :: Num a => Vector a -> a Source # product :: Num a => Vector a -> a Source #
Foldable ( Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 Source # toList :: Either a a0 -> [a0] Source # null :: Either a a0 -> Bool Source # length :: Either a a0 -> Int Source # elem :: Eq a0 => a0 -> Either a a0 -> Bool Source # maximum :: Ord a0 => Either a a0 -> a0 Source # minimum :: Ord a0 => Either a a0 -> a0 Source # sum :: Num a0 => Either a a0 -> a0 Source # product :: Num a0 => Either a a0 -> a0 Source #
Foldable ( V1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => V1 m -> m Source # foldMap :: Monoid m => (a -> m) -> V1 a -> m Source # foldMap' :: Monoid m => (a -> m) -> V1 a -> m Source # foldr :: (a -> b -> b) -> b -> V1 a -> b Source # foldr' :: (a -> b -> b) -> b -> V1 a -> b Source # foldl :: (b -> a -> b) -> b -> V1 a -> b Source # foldl' :: (b -> a -> b) -> b -> V1 a -> b Source # foldr1 :: (a -> a -> a) -> V1 a -> a Source # foldl1 :: (a -> a -> a) -> V1 a -> a Source # toList :: V1 a -> [a] Source # null :: V1 a -> Bool Source # length :: V1 a -> Int Source # elem :: Eq a => a -> V1 a -> Bool Source # maximum :: Ord a => V1 a -> a Source # minimum :: Ord a => V1 a -> a Source # sum :: Num a => V1 a -> a Source # product :: Num a => V1 a -> a Source #
Foldable ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => U1 m -> m Source # foldMap :: Monoid m => (a -> m) -> U1 a -> m Source # foldMap' :: Monoid m => (a -> m) -> U1 a -> m Source # foldr :: (a -> b -> b) -> b -> U1 a -> b Source # foldr' :: (a -> b -> b) -> b -> U1 a -> b Source # foldl :: (b -> a -> b) -> b -> U1 a -> b Source # foldl' :: (b -> a -> b) -> b -> U1 a -> b Source # foldr1 :: (a -> a -> a) -> U1 a -> a Source # foldl1 :: (a -> a -> a) -> U1 a -> a Source # toList :: U1 a -> [a] Source # null :: U1 a -> Bool Source # length :: U1 a -> Int Source # elem :: Eq a => a -> U1 a -> Bool Source # maximum :: Ord a => U1 a -> a Source # minimum :: Ord a => U1 a -> a Source # sum :: Num a => U1 a -> a Source # product :: Num a => U1 a -> a Source #
Foldable ( UAddr :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m Source # foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source # foldr :: (a -> b -> b) -> b -> UAddr a -> b Source # foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source # foldl :: (b -> a -> b) -> b -> UAddr a -> b Source # foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source # foldr1 :: (a -> a -> a) -> UAddr a -> a Source # foldl1 :: (a -> a -> a) -> UAddr a -> a Source # toList :: UAddr a -> [a] Source # null :: UAddr a -> Bool Source # length :: UAddr a -> Int Source # elem :: Eq a => a -> UAddr a -> Bool Source # maximum :: Ord a => UAddr a -> a Source # minimum :: Ord a => UAddr a -> a Source # sum :: Num a => UAddr a -> a Source # product :: Num a => UAddr a -> a Source #
Foldable ( UChar :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m Source # foldMap :: Monoid m => (a -> m) -> UChar a -> m Source # foldMap' :: Monoid m => (a -> m) -> UChar a -> m Source # foldr :: (a -> b -> b) -> b -> UChar a -> b Source # foldr' :: (a -> b -> b) -> b -> UChar a -> b Source # foldl :: (b -> a -> b) -> b -> UChar a -> b Source # foldl' :: (b -> a -> b) -> b -> UChar a -> b Source # foldr1 :: (a -> a -> a) -> UChar a -> a Source # foldl1 :: (a -> a -> a) -> UChar a -> a Source # toList :: UChar a -> [a] Source # null :: UChar a -> Bool Source # length :: UChar a -> Int Source # elem :: Eq a => a -> UChar a -> Bool Source # maximum :: Ord a => UChar a -> a Source # minimum :: Ord a => UChar a -> a Source # sum :: Num a => UChar a -> a Source # product :: Num a => UChar a -> a Source #
Foldable ( UDouble :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m Source # foldMap :: Monoid m => (a -> m) -> UDouble a -> m Source # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m Source # foldr :: (a -> b -> b) -> b -> UDouble a -> b Source # foldr' :: (a -> b -> b) -> b -> UDouble a -> b Source # foldl :: (b -> a -> b) -> b -> UDouble a -> b Source # foldl' :: (b -> a -> b) -> b -> UDouble a -> b Source # foldr1 :: (a -> a -> a) -> UDouble a -> a Source # foldl1 :: (a -> a -> a) -> UDouble a -> a Source # toList :: UDouble a -> [a] Source # null :: UDouble a -> Bool Source # length :: UDouble a -> Int Source # elem :: Eq a => a -> UDouble a -> Bool Source # maximum :: Ord a => UDouble a -> a Source # minimum :: Ord a => UDouble a -> a Source # sum :: Num a => UDouble a -> a Source # product :: Num a => UDouble a -> a Source #
Foldable ( UFloat :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m Source # foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source # foldr :: (a -> b -> b) -> b -> UFloat a -> b Source # foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source # foldl :: (b -> a -> b) -> b -> UFloat a -> b Source # foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source # foldr1 :: (a -> a -> a) -> UFloat a -> a Source # foldl1 :: (a -> a -> a) -> UFloat a -> a Source # toList :: UFloat a -> [a] Source # null :: UFloat a -> Bool Source # length :: UFloat a -> Int Source # elem :: Eq a => a -> UFloat a -> Bool Source # maximum :: Ord a => UFloat a -> a Source # minimum :: Ord a => UFloat a -> a Source # sum :: Num a => UFloat a -> a Source # product :: Num a => UFloat a -> a Source #
Foldable ( UInt :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m Source # foldMap :: Monoid m => (a -> m) -> UInt a -> m Source # foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source # foldr :: (a -> b -> b) -> b -> UInt a -> b Source # foldr' :: (a -> b -> b) -> b -> UInt a -> b Source # foldl :: (b -> a -> b) -> b -> UInt a -> b Source # foldl' :: (b -> a -> b) -> b -> UInt a -> b Source # foldr1 :: (a -> a -> a) -> UInt a -> a Source # foldl1 :: (a -> a -> a) -> UInt a -> a Source # toList :: UInt a -> [a] Source # null :: UInt a -> Bool Source # length :: UInt a -> Int Source # elem :: Eq a => a -> UInt a -> Bool Source # maximum :: Ord a => UInt a -> a Source # minimum :: Ord a => UInt a -> a Source # sum :: Num a => UInt a -> a Source # product :: Num a => UInt a -> a Source #
Foldable ( UWord :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m Source # foldMap :: Monoid m => (a -> m) -> UWord a -> m Source # foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source # foldr :: (a -> b -> b) -> b -> UWord a -> b Source # foldr' :: (a -> b -> b) -> b -> UWord a -> b Source # foldl :: (b -> a -> b) -> b -> UWord a -> b Source # foldl' :: (b -> a -> b) -> b -> UWord a -> b Source # foldr1 :: (a -> a -> a) -> UWord a -> a Source # foldl1 :: (a -> a -> a) -> UWord a -> a Source # toList :: UWord a -> [a] Source # null :: UWord a -> Bool Source # length :: UWord a -> Int Source # elem :: Eq a => a -> UWord a -> Bool Source # maximum :: Ord a => UWord a -> a Source # minimum :: Ord a => UWord a -> a Source # sum :: Num a => UWord a -> a Source # product :: Num a => UWord a -> a Source #
Foldable ( (,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m Source # foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m Source # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m Source # foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b Source # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b Source # foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b Source # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b Source # foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 Source # toList :: (a, a0) -> [a0] Source # null :: (a, a0) -> Bool Source # length :: (a, a0) -> Int Source # elem :: Eq a0 => a0 -> (a, a0) -> Bool Source # maximum :: Ord a0 => (a, a0) -> a0 Source # minimum :: Ord a0 => (a, a0) -> a0 Source # sum :: Num a0 => (a, a0) -> a0 Source # product :: Num a0 => (a, a0) -> a0 Source #
Foldable ( Map k)	Folds in order of increasing key.
Instance details Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m Source # foldMap :: Monoid m => (a -> m) -> Map k a -> m Source # foldMap' :: Monoid m => (a -> m) -> Map k a -> m Source # foldr :: (a -> b -> b) -> b -> Map k a -> b Source # foldr' :: (a -> b -> b) -> b -> Map k a -> b Source # foldl :: (b -> a -> b) -> b -> Map k a -> b Source # foldl' :: (b -> a -> b) -> b -> Map k a -> b Source # foldr1 :: (a -> a -> a) -> Map k a -> a Source # foldl1 :: (a -> a -> a) -> Map k a -> a Source # toList :: Map k a -> [a] Source # null :: Map k a -> Bool Source # length :: Map k a -> Int Source # elem :: Eq a => a -> Map k a -> Bool Source # maximum :: Ord a => Map k a -> a Source # minimum :: Ord a => Map k a -> a Source # sum :: Num a => Map k a -> a Source # product :: Num a => Map k a -> a Source #
Foldable ( HashMap k)
Instance details Defined in Data.HashMap.Internal Methods fold :: Monoid m => HashMap k m -> m Source # foldMap :: Monoid m => (a -> m) -> HashMap k a -> m Source # foldMap' :: Monoid m => (a -> m) -> HashMap k a -> m Source # foldr :: (a -> b -> b) -> b -> HashMap k a -> b Source # foldr' :: (a -> b -> b) -> b -> HashMap k a -> b Source # foldl :: (b -> a -> b) -> b -> HashMap k a -> b Source # foldl' :: (b -> a -> b) -> b -> HashMap k a -> b Source # foldr1 :: (a -> a -> a) -> HashMap k a -> a Source # foldl1 :: (a -> a -> a) -> HashMap k a -> a Source # toList :: HashMap k a -> [a] Source # null :: HashMap k a -> Bool Source # length :: HashMap k a -> Int Source # elem :: Eq a => a -> HashMap k a -> Bool Source # maximum :: Ord a => HashMap k a -> a Source # minimum :: Ord a => HashMap k a -> a Source # sum :: Num a => HashMap k a -> a Source # product :: Num a => HashMap k a -> a Source #
Foldable ( Array i)	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m Source # foldMap :: Monoid m => (a -> m) -> Array i a -> m Source # foldMap' :: Monoid m => (a -> m) -> Array i a -> m Source # foldr :: (a -> b -> b) -> b -> Array i a -> b Source # foldr' :: (a -> b -> b) -> b -> Array i a -> b Source # foldl :: (b -> a -> b) -> b -> Array i a -> b Source # foldl' :: (b -> a -> b) -> b -> Array i a -> b Source # foldr1 :: (a -> a -> a) -> Array i a -> a Source # foldl1 :: (a -> a -> a) -> Array i a -> a Source # toList :: Array i a -> [a] Source # null :: Array i a -> Bool Source # length :: Array i a -> Int Source # elem :: Eq a => a -> Array i a -> Bool Source # maximum :: Ord a => Array i a -> a Source # minimum :: Ord a => Array i a -> a Source # sum :: Num a => Array i a -> a Source # product :: Num a => Array i a -> a Source #
Foldable ( Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 Source # toList :: Arg a a0 -> [a0] Source # null :: Arg a a0 -> Bool Source # length :: Arg a a0 -> Int Source # elem :: Eq a0 => a0 -> Arg a a0 -> Bool Source # maximum :: Ord a0 => Arg a a0 -> a0 Source # minimum :: Ord a0 => Arg a a0 -> a0 Source # sum :: Num a0 => Arg a a0 -> a0 Source # product :: Num a0 => Arg a a0 -> a0 Source #
Foldable ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m Source # foldMap :: Monoid m => (a -> m) -> Proxy a -> m Source # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m Source # foldr :: (a -> b -> b) -> b -> Proxy a -> b Source # foldr' :: (a -> b -> b) -> b -> Proxy a -> b Source # foldl :: (b -> a -> b) -> b -> Proxy a -> b Source # foldl' :: (b -> a -> b) -> b -> Proxy a -> b Source # foldr1 :: (a -> a -> a) -> Proxy a -> a Source # foldl1 :: (a -> a -> a) -> Proxy a -> a Source # toList :: Proxy a -> [a] Source # null :: Proxy a -> Bool Source # length :: Proxy a -> Int Source # elem :: Eq a => a -> Proxy a -> Bool Source # maximum :: Ord a => Proxy a -> a Source # minimum :: Ord a => Proxy a -> a Source # sum :: Num a => Proxy a -> a Source # product :: Num a => Proxy a -> a Source #
Foldable f => Foldable ( ListT f)
Instance details Defined in Control.Monad.Trans.List Methods fold :: Monoid m => ListT f m -> m Source # foldMap :: Monoid m => (a -> m) -> ListT f a -> m Source # foldMap' :: Monoid m => (a -> m) -> ListT f a -> m Source # foldr :: (a -> b -> b) -> b -> ListT f a -> b Source # foldr' :: (a -> b -> b) -> b -> ListT f a -> b Source # foldl :: (b -> a -> b) -> b -> ListT f a -> b Source # foldl' :: (b -> a -> b) -> b -> ListT f a -> b Source # foldr1 :: (a -> a -> a) -> ListT f a -> a Source # foldl1 :: (a -> a -> a) -> ListT f a -> a Source # toList :: ListT f a -> [a] Source # null :: ListT f a -> Bool Source # length :: ListT f a -> Int Source # elem :: Eq a => a -> ListT f a -> Bool Source # maximum :: Ord a => ListT f a -> a Source # minimum :: Ord a => ListT f a -> a Source # sum :: Num a => ListT f a -> a Source # product :: Num a => ListT f a -> a Source #
Foldable ( These a)
Instance details Defined in Data.These Methods fold :: Monoid m => These a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> These a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> These a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> These a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> These a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> These a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> These a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 Source # toList :: These a a0 -> [a0] Source # null :: These a a0 -> Bool Source # length :: These a a0 -> Int Source # elem :: Eq a0 => a0 -> These a a0 -> Bool Source # maximum :: Ord a0 => These a a0 -> a0 Source # minimum :: Ord a0 => These a a0 -> a0 Source # sum :: Num a0 => These a a0 -> a0 Source # product :: Num a0 => These a a0 -> a0 Source #
Foldable ( Pair e)
Instance details Defined in Data.Strict.Tuple Methods fold :: Monoid m => Pair e m -> m Source # foldMap :: Monoid m => (a -> m) -> Pair e a -> m Source # foldMap' :: Monoid m => (a -> m) -> Pair e a -> m Source # foldr :: (a -> b -> b) -> b -> Pair e a -> b Source # foldr' :: (a -> b -> b) -> b -> Pair e a -> b Source # foldl :: (b -> a -> b) -> b -> Pair e a -> b Source # foldl' :: (b -> a -> b) -> b -> Pair e a -> b Source # foldr1 :: (a -> a -> a) -> Pair e a -> a Source # foldl1 :: (a -> a -> a) -> Pair e a -> a Source # toList :: Pair e a -> [a] Source # null :: Pair e a -> Bool Source # length :: Pair e a -> Int Source # elem :: Eq a => a -> Pair e a -> Bool Source # maximum :: Ord a => Pair e a -> a Source # minimum :: Ord a => Pair e a -> a Source # sum :: Num a => Pair e a -> a Source # product :: Num a => Pair e a -> a Source #
Foldable ( These a)
Instance details Defined in Data.Strict.These Methods fold :: Monoid m => These a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> These a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> These a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> These a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> These a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> These a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> These a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 Source # toList :: These a a0 -> [a0] Source # null :: These a a0 -> Bool Source # length :: These a a0 -> Int Source # elem :: Eq a0 => a0 -> These a a0 -> Bool Source # maximum :: Ord a0 => These a a0 -> a0 Source # minimum :: Ord a0 => These a a0 -> a0 Source # sum :: Num a0 => These a a0 -> a0 Source # product :: Num a0 => These a a0 -> a0 Source #
Foldable ( Either e)
Instance details Defined in Data.Strict.Either Methods fold :: Monoid m => Either e m -> m Source # foldMap :: Monoid m => (a -> m) -> Either e a -> m Source # foldMap' :: Monoid m => (a -> m) -> Either e a -> m Source # foldr :: (a -> b -> b) -> b -> Either e a -> b Source # foldr' :: (a -> b -> b) -> b -> Either e a -> b Source # foldl :: (b -> a -> b) -> b -> Either e a -> b Source # foldl' :: (b -> a -> b) -> b -> Either e a -> b Source # foldr1 :: (a -> a -> a) -> Either e a -> a Source # foldl1 :: (a -> a -> a) -> Either e a -> a Source # toList :: Either e a -> [a] Source # null :: Either e a -> Bool Source # length :: Either e a -> Int Source # elem :: Eq a => a -> Either e a -> Bool Source # maximum :: Ord a => Either e a -> a Source # minimum :: Ord a => Either e a -> a Source # sum :: Num a => Either e a -> a Source # product :: Num a => Either e a -> a Source #
Foldable f => Foldable ( MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m Source # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m Source # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m Source # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b Source # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b Source # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b Source # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b Source # foldr1 :: (a -> a -> a) -> MaybeT f a -> a Source # foldl1 :: (a -> a -> a) -> MaybeT f a -> a Source # toList :: MaybeT f a -> [a] Source # null :: MaybeT f a -> Bool Source # length :: MaybeT f a -> Int Source # elem :: Eq a => a -> MaybeT f a -> Bool Source # maximum :: Ord a => MaybeT f a -> a Source # minimum :: Ord a => MaybeT f a -> a Source # sum :: Num a => MaybeT f a -> a Source # product :: Num a => MaybeT f a -> a Source #
Foldable f => Foldable ( Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m Source # foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m Source # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m Source # foldr :: (a -> b -> b) -> b -> Rec1 f a -> b Source # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b Source # foldl :: (b -> a -> b) -> b -> Rec1 f a -> b Source # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b Source # foldr1 :: (a -> a -> a) -> Rec1 f a -> a Source # foldl1 :: (a -> a -> a) -> Rec1 f a -> a Source # toList :: Rec1 f a -> [a] Source # null :: Rec1 f a -> Bool Source # length :: Rec1 f a -> Int Source # elem :: Eq a => a -> Rec1 f a -> Bool Source # maximum :: Ord a => Rec1 f a -> a Source # minimum :: Ord a => Rec1 f a -> a Source # sum :: Num a => Rec1 f a -> a Source # product :: Num a => Rec1 f a -> a Source #
Foldable ( Const m :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 Source # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldr :: (a -> b -> b) -> b -> Const m a -> b Source # foldr' :: (a -> b -> b) -> b -> Const m a -> b Source # foldl :: (b -> a -> b) -> b -> Const m a -> b Source # foldl' :: (b -> a -> b) -> b -> Const m a -> b Source # foldr1 :: (a -> a -> a) -> Const m a -> a Source # foldl1 :: (a -> a -> a) -> Const m a -> a Source # toList :: Const m a -> [a] Source # null :: Const m a -> Bool Source # length :: Const m a -> Int Source # elem :: Eq a => a -> Const m a -> Bool Source # maximum :: Ord a => Const m a -> a Source # minimum :: Ord a => Const m a -> a Source # sum :: Num a => Const m a -> a Source # product :: Num a => Const m a -> a Source #
Foldable f => Foldable ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m Source # foldMap :: Monoid m => (a -> m) -> Ap f a -> m Source # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m Source # foldr :: (a -> b -> b) -> b -> Ap f a -> b Source # foldr' :: (a -> b -> b) -> b -> Ap f a -> b Source # foldl :: (b -> a -> b) -> b -> Ap f a -> b Source # foldl' :: (b -> a -> b) -> b -> Ap f a -> b Source # foldr1 :: (a -> a -> a) -> Ap f a -> a Source # foldl1 :: (a -> a -> a) -> Ap f a -> a Source # toList :: Ap f a -> [a] Source # null :: Ap f a -> Bool Source # length :: Ap f a -> Int Source # elem :: Eq a => a -> Ap f a -> Bool Source # maximum :: Ord a => Ap f a -> a Source # minimum :: Ord a => Ap f a -> a Source # sum :: Num a => Ap f a -> a Source # product :: Num a => Ap f a -> a Source #
Foldable f => Foldable ( Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m Source # foldMap :: Monoid m => (a -> m) -> Alt f a -> m Source # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m Source # foldr :: (a -> b -> b) -> b -> Alt f a -> b Source # foldr' :: (a -> b -> b) -> b -> Alt f a -> b Source # foldl :: (b -> a -> b) -> b -> Alt f a -> b Source # foldl' :: (b -> a -> b) -> b -> Alt f a -> b Source # foldr1 :: (a -> a -> a) -> Alt f a -> a Source # foldl1 :: (a -> a -> a) -> Alt f a -> a Source # toList :: Alt f a -> [a] Source # null :: Alt f a -> Bool Source # length :: Alt f a -> Int Source # elem :: Eq a => a -> Alt f a -> Bool Source # maximum :: Ord a => Alt f a -> a Source # minimum :: Ord a => Alt f a -> a Source # sum :: Num a => Alt f a -> a Source # product :: Num a => Alt f a -> a Source #
Foldable f => Foldable ( IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m Source # foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m Source # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m Source # foldr :: (a -> b -> b) -> b -> IdentityT f a -> b Source # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b Source # foldl :: (b -> a -> b) -> b -> IdentityT f a -> b Source # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b Source # foldr1 :: (a -> a -> a) -> IdentityT f a -> a Source # foldl1 :: (a -> a -> a) -> IdentityT f a -> a Source # toList :: IdentityT f a -> [a] Source # null :: IdentityT f a -> Bool Source # length :: IdentityT f a -> Int Source # elem :: Eq a => a -> IdentityT f a -> Bool Source # maximum :: Ord a => IdentityT f a -> a Source # minimum :: Ord a => IdentityT f a -> a Source # sum :: Num a => IdentityT f a -> a Source # product :: Num a => IdentityT f a -> a Source #
Foldable f => Foldable ( ErrorT e f)
Instance details Defined in Control.Monad.Trans.Error Methods fold :: Monoid m => ErrorT e f m -> m Source # foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m Source # foldMap' :: Monoid m => (a -> m) -> ErrorT e f a -> m Source # foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b Source # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b Source # foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b Source # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b Source # foldr1 :: (a -> a -> a) -> ErrorT e f a -> a Source # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a Source # toList :: ErrorT e f a -> [a] Source # null :: ErrorT e f a -> Bool Source # length :: ErrorT e f a -> Int Source # elem :: Eq a => a -> ErrorT e f a -> Bool Source # maximum :: Ord a => ErrorT e f a -> a Source # minimum :: Ord a => ErrorT e f a -> a Source # sum :: Num a => ErrorT e f a -> a Source # product :: Num a => ErrorT e f a -> a Source #
Foldable f => Foldable ( ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m Source # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m Source # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m Source # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b Source # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b Source # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b Source # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b Source # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a Source # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a Source # toList :: ExceptT e f a -> [a] Source # null :: ExceptT e f a -> Bool Source # length :: ExceptT e f a -> Int Source # elem :: Eq a => a -> ExceptT e f a -> Bool Source # maximum :: Ord a => ExceptT e f a -> a Source # minimum :: Ord a => ExceptT e f a -> a Source # sum :: Num a => ExceptT e f a -> a Source # product :: Num a => ExceptT e f a -> a Source #
Foldable f => Foldable ( WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m Source # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m Source # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m Source # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b Source # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b Source # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b Source # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b Source # foldr1 :: (a -> a -> a) -> WriterT w f a -> a Source # foldl1 :: (a -> a -> a) -> WriterT w f a -> a Source # toList :: WriterT w f a -> [a] Source # null :: WriterT w f a -> Bool Source # length :: WriterT w f a -> Int Source # elem :: Eq a => a -> WriterT w f a -> Bool Source # maximum :: Ord a => WriterT w f a -> a Source # minimum :: Ord a => WriterT w f a -> a Source # sum :: Num a => WriterT w f a -> a Source # product :: Num a => WriterT w f a -> a Source #
Foldable f => Foldable ( WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods fold :: Monoid m => WriterT w f m -> m Source # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m Source # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m Source # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b Source # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b Source # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b Source # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b Source # foldr1 :: (a -> a -> a) -> WriterT w f a -> a Source # foldl1 :: (a -> a -> a) -> WriterT w f a -> a Source # toList :: WriterT w f a -> [a] Source # null :: WriterT w f a -> Bool Source # length :: WriterT w f a -> Int Source # elem :: Eq a => a -> WriterT w f a -> Bool Source # maximum :: Ord a => WriterT w f a -> a Source # minimum :: Ord a => WriterT w f a -> a Source # sum :: Num a => WriterT w f a -> a Source # product :: Num a => WriterT w f a -> a Source #
Foldable ( Tagged s)
Instance details Defined in Data.Tagged Methods fold :: Monoid m => Tagged s m -> m Source # foldMap :: Monoid m => (a -> m) -> Tagged s a -> m Source # foldMap' :: Monoid m => (a -> m) -> Tagged s a -> m Source # foldr :: (a -> b -> b) -> b -> Tagged s a -> b Source # foldr' :: (a -> b -> b) -> b -> Tagged s a -> b Source # foldl :: (b -> a -> b) -> b -> Tagged s a -> b Source # foldl' :: (b -> a -> b) -> b -> Tagged s a -> b Source # foldr1 :: (a -> a -> a) -> Tagged s a -> a Source # foldl1 :: (a -> a -> a) -> Tagged s a -> a Source # toList :: Tagged s a -> [a] Source # null :: Tagged s a -> Bool Source # length :: Tagged s a -> Int Source # elem :: Eq a => a -> Tagged s a -> Bool Source # maximum :: Ord a => Tagged s a -> a Source # minimum :: Ord a => Tagged s a -> a Source # sum :: Num a => Tagged s a -> a Source # product :: Num a => Tagged s a -> a Source #
( Foldable f, Foldable g) => Foldable ( These1 f g)
Instance details Defined in Data.Functor.These Methods fold :: Monoid m => These1 f g m -> m Source # foldMap :: Monoid m => (a -> m) -> These1 f g a -> m Source # foldMap' :: Monoid m => (a -> m) -> These1 f g a -> m Source # foldr :: (a -> b -> b) -> b -> These1 f g a -> b Source # foldr' :: (a -> b -> b) -> b -> These1 f g a -> b Source # foldl :: (b -> a -> b) -> b -> These1 f g a -> b Source # foldl' :: (b -> a -> b) -> b -> These1 f g a -> b Source # foldr1 :: (a -> a -> a) -> These1 f g a -> a Source # foldl1 :: (a -> a -> a) -> These1 f g a -> a Source # toList :: These1 f g a -> [a] Source # null :: These1 f g a -> Bool Source # length :: These1 f g a -> Int Source # elem :: Eq a => a -> These1 f g a -> Bool Source # maximum :: Ord a => These1 f g a -> a Source # minimum :: Ord a => These1 f g a -> a Source # sum :: Num a => These1 f g a -> a Source # product :: Num a => These1 f g a -> a Source #
Foldable ( K1 i c :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m Source # foldMap :: Monoid m => (a -> m) -> K1 i c a -> m Source # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m Source # foldr :: (a -> b -> b) -> b -> K1 i c a -> b Source # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b Source # foldl :: (b -> a -> b) -> b -> K1 i c a -> b Source # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b Source # foldr1 :: (a -> a -> a) -> K1 i c a -> a Source # foldl1 :: (a -> a -> a) -> K1 i c a -> a Source # toList :: K1 i c a -> [a] Source # null :: K1 i c a -> Bool Source # length :: K1 i c a -> Int Source # elem :: Eq a => a -> K1 i c a -> Bool Source # maximum :: Ord a => K1 i c a -> a Source # minimum :: Ord a => K1 i c a -> a Source # sum :: Num a => K1 i c a -> a Source # product :: Num a => K1 i c a -> a Source #
( Foldable f, Foldable g) => Foldable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m Source # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m Source # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b Source # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b Source # foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b Source # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b Source # foldr1 :: (a -> a -> a) -> (f :+: g) a -> a Source # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a Source # toList :: (f :+: g) a -> [a] Source # null :: (f :+: g) a -> Bool Source # length :: (f :+: g) a -> Int Source # elem :: Eq a => a -> (f :+: g) a -> Bool Source # maximum :: Ord a => (f :+: g) a -> a Source # minimum :: Ord a => (f :+: g) a -> a Source # sum :: Num a => (f :+: g) a -> a Source # product :: Num a => (f :+: g) a -> a Source #
( Foldable f, Foldable g) => Foldable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :: g) a -> m Source # foldMap' :: Monoid m => (a -> m) -> (f :: g) a -> m Source # foldr :: (a -> b -> b) -> b -> (f :: g) a -> b Source # foldr' :: (a -> b -> b) -> b -> (f :: g) a -> b Source # foldl :: (b -> a -> b) -> b -> (f :: g) a -> b Source # foldl' :: (b -> a -> b) -> b -> (f :: g) a -> b Source # foldr1 :: (a -> a -> a) -> (f :: g) a -> a Source # foldl1 :: (a -> a -> a) -> (f :: g) a -> a Source # toList :: (f :: g) a -> [a] Source # null :: (f :: g) a -> Bool Source # length :: (f :: g) a -> Int Source # elem :: Eq a => a -> (f :: g) a -> Bool Source # maximum :: Ord a => (f :: g) a -> a Source # minimum :: Ord a => (f :: g) a -> a Source # sum :: Num a => (f :: g) a -> a Source # product :: Num a => (f :*: g) a -> a Source #
( Foldable f, Foldable g) => Foldable ( Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Product f g a -> m Source # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m Source # foldr :: (a -> b -> b) -> b -> Product f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Product f g a -> b Source # foldl :: (b -> a -> b) -> b -> Product f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Product f g a -> b Source # foldr1 :: (a -> a -> a) -> Product f g a -> a Source # foldl1 :: (a -> a -> a) -> Product f g a -> a Source # toList :: Product f g a -> [a] Source # null :: Product f g a -> Bool Source # length :: Product f g a -> Int Source # elem :: Eq a => a -> Product f g a -> Bool Source # maximum :: Ord a => Product f g a -> a Source # minimum :: Ord a => Product f g a -> a Source # sum :: Num a => Product f g a -> a Source # product :: Num a => Product f g a -> a Source #
( Foldable f, Foldable g) => Foldable ( Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Sum f g a -> m Source # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m Source # foldr :: (a -> b -> b) -> b -> Sum f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b Source # foldl :: (b -> a -> b) -> b -> Sum f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b Source # foldr1 :: (a -> a -> a) -> Sum f g a -> a Source # foldl1 :: (a -> a -> a) -> Sum f g a -> a Source # toList :: Sum f g a -> [a] Source # null :: Sum f g a -> Bool Source # length :: Sum f g a -> Int Source # elem :: Eq a => a -> Sum f g a -> Bool Source # maximum :: Ord a => Sum f g a -> a Source # minimum :: Ord a => Sum f g a -> a Source # sum :: Num a => Sum f g a -> a Source # product :: Num a => Sum f g a -> a Source #
Foldable f => Foldable ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m Source # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m Source # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m Source # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b Source # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b Source # foldl :: (b -> a -> b) -> b -> M1 i c f a -> b Source # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b Source # foldr1 :: (a -> a -> a) -> M1 i c f a -> a Source # foldl1 :: (a -> a -> a) -> M1 i c f a -> a Source # toList :: M1 i c f a -> [a] Source # null :: M1 i c f a -> Bool Source # length :: M1 i c f a -> Int Source # elem :: Eq a => a -> M1 i c f a -> Bool Source # maximum :: Ord a => M1 i c f a -> a Source # minimum :: Ord a => M1 i c f a -> a Source # sum :: Num a => M1 i c f a -> a Source # product :: Num a => M1 i c f a -> a Source #
( Foldable f, Foldable g) => Foldable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m Source # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m Source # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b Source # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b Source # foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b Source # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b Source # foldr1 :: (a -> a -> a) -> (f :.: g) a -> a Source # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a Source # toList :: (f :.: g) a -> [a] Source # null :: (f :.: g) a -> Bool Source # length :: (f :.: g) a -> Int Source # elem :: Eq a => a -> (f :.: g) a -> Bool Source # maximum :: Ord a => (f :.: g) a -> a Source # minimum :: Ord a => (f :.: g) a -> a Source # sum :: Num a => (f :.: g) a -> a Source # product :: Num a => (f :.: g) a -> a Source #
( Foldable f, Foldable g) => Foldable ( Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m Source # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m Source # foldr :: (a -> b -> b) -> b -> Compose f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b Source # foldl :: (b -> a -> b) -> b -> Compose f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b Source # foldr1 :: (a -> a -> a) -> Compose f g a -> a Source # foldl1 :: (a -> a -> a) -> Compose f g a -> a Source # toList :: Compose f g a -> [a] Source # null :: Compose f g a -> Bool Source # length :: Compose f g a -> Int Source # elem :: Eq a => a -> Compose f g a -> Bool Source # maximum :: Ord a => Compose f g a -> a Source # minimum :: Ord a => Compose f g a -> a Source # sum :: Num a => Compose f g a -> a Source # product :: Num a => Compose f g a -> a Source #
Bifoldable p => Foldable ( Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods fold :: Monoid m => Flip p a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Flip p a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Flip p a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Flip p a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Flip p a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Flip p a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Flip p a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0 Source # toList :: Flip p a a0 -> [a0] Source # null :: Flip p a a0 -> Bool Source # length :: Flip p a a0 -> Int Source # elem :: Eq a0 => a0 -> Flip p a a0 -> Bool Source # maximum :: Ord a0 => Flip p a a0 -> a0 Source # minimum :: Ord a0 => Flip p a a0 -> a0 Source # sum :: Num a0 => Flip p a a0 -> a0 Source # product :: Num a0 => Flip p a a0 -> a0 Source #
( Foldable (f a), Foldable (g a)) => Foldable ( Sum f g a)
Instance details Defined in Data.Bifunctor.Sum Methods fold :: Monoid m => Sum f g a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Sum f g a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Sum f g a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Sum f g a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Sum f g a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Sum f g a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Sum f g a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Sum f g a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Sum f g a a0 -> a0 Source # toList :: Sum f g a a0 -> [a0] Source # null :: Sum f g a a0 -> Bool Source # length :: Sum f g a a0 -> Int Source # elem :: Eq a0 => a0 -> Sum f g a a0 -> Bool Source # maximum :: Ord a0 => Sum f g a a0 -> a0 Source # minimum :: Ord a0 => Sum f g a a0 -> a0 Source # sum :: Num a0 => Sum f g a a0 -> a0 Source # product :: Num a0 => Sum f g a a0 -> a0 Source #
( Foldable (f a), Foldable (g a)) => Foldable ( Product f g a)
Instance details Defined in Data.Bifunctor.Product Methods fold :: Monoid m => Product f g a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Product f g a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Product f g a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Product f g a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Product f g a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Product f g a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Product f g a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Product f g a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Product f g a a0 -> a0 Source # toList :: Product f g a a0 -> [a0] Source # null :: Product f g a a0 -> Bool Source # length :: Product f g a a0 -> Int Source # elem :: Eq a0 => a0 -> Product f g a a0 -> Bool Source # maximum :: Ord a0 => Product f g a a0 -> a0 Source # minimum :: Ord a0 => Product f g a a0 -> a0 Source # sum :: Num a0 => Product f g a a0 -> a0 Source # product :: Num a0 => Product f g a a0 -> a0 Source #
( Foldable f, Bifoldable p) => Foldable ( Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods fold :: Monoid m => Tannen f p a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0 Source # toList :: Tannen f p a a0 -> [a0] Source # null :: Tannen f p a a0 -> Bool Source # length :: Tannen f p a a0 -> Int Source # elem :: Eq a0 => a0 -> Tannen f p a a0 -> Bool Source # maximum :: Ord a0 => Tannen f p a a0 -> a0 Source # minimum :: Ord a0 => Tannen f p a a0 -> a0 Source # sum :: Num a0 => Tannen f p a a0 -> a0 Source # product :: Num a0 => Tannen f p a a0 -> a0 Source #
( Bifoldable p, Foldable g) => Foldable ( Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods fold :: Monoid m => Biff p f g a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0 Source # toList :: Biff p f g a a0 -> [a0] Source # null :: Biff p f g a a0 -> Bool Source # length :: Biff p f g a a0 -> Int Source # elem :: Eq a0 => a0 -> Biff p f g a a0 -> Bool Source # maximum :: Ord a0 => Biff p f g a a0 -> a0 Source # minimum :: Ord a0 => Biff p f g a a0 -> a0 Source # sum :: Num a0 => Biff p f g a a0 -> a0 Source # product :: Num a0 => Biff p f g a a0 -> a0 Source #

class ( Functor t, Foldable t) => Traversable (t :: Type -> Type ) where Source #

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

Naturality: t . traverse f = traverse (t . f) for every applicative transformation t
Identity: traverse Identity = Identity
Composition: traverse ( Compose . fmap g . f) = Compose . fmap ( traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

Naturality: t . sequenceA = sequenceA . fmap t for every applicative transformation t
Identity: sequenceA . fmap Identity = Identity
Composition: sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

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

and the identity functor Identity and composition functors Compose are from Data.Functor.Identity and Data.Functor.Compose .

A result of the naturality law is a purity law for traverse

traverse pure = pure

(The naturality law is implied by parametricity and thus so is the purity law [1, p15].)

Instances are similar to Functor , e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor ( fmapDefault ).
In the Foldable instance, foldMap should be equivalent to traversal with a constant applicative functor ( foldMapDefault ).

References: [1] The Essence of the Iterator Pattern, Jeremy Gibbons and Bruno C. d. S. Oliveira

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) Source #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_ .

sequenceA :: Applicative f => t (f a) -> f (t a) Source #

Evaluate each action in the structure from left to right, and collect the results. For a version that ignores the results see sequenceA_ .

mapM :: Monad m => (a -> m b) -> t a -> m (t b) Source #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_ .

sequence :: Monad m => t (m a) -> m (t a) Source #

Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_ .

Instances

Instances details

Traversable []	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] Source # sequenceA :: Applicative f => [f a] -> f [a] Source # mapM :: Monad m => (a -> m b) -> [a] -> m [b] Source # sequence :: Monad m => [m a] -> m [a] Source #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f ( Maybe b) Source # sequenceA :: Applicative f => Maybe (f a) -> f ( Maybe a) Source # mapM :: Monad m => (a -> m b) -> Maybe a -> m ( Maybe b) Source # sequence :: Monad m => Maybe (m a) -> m ( Maybe a) Source #
Traversable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Par1 a -> f ( Par1 b) Source # sequenceA :: Applicative f => Par1 (f a) -> f ( Par1 a) Source # mapM :: Monad m => (a -> m b) -> Par1 a -> m ( Par1 b) Source # sequence :: Monad m => Par1 (m a) -> m ( Par1 a) Source #
Traversable Solo
Instance details Defined in Data.Tuple.Solo Methods traverse :: Applicative f => (a -> f b) -> Solo a -> f ( Solo b) Source # sequenceA :: Applicative f => Solo (f a) -> f ( Solo a) Source # mapM :: Monad m => (a -> m b) -> Solo a -> m ( Solo b) Source # sequence :: Monad m => Solo (m a) -> m ( Solo a) Source #
Traversable IResult
Instance details Defined in Data.Aeson.Types.Internal Methods traverse :: Applicative f => (a -> f b) -> IResult a -> f ( IResult b) Source # sequenceA :: Applicative f => IResult (f a) -> f ( IResult a) Source # mapM :: Monad m => (a -> m b) -> IResult a -> m ( IResult b) Source # sequence :: Monad m => IResult (m a) -> m ( IResult a) Source #
Traversable Result
Instance details Defined in Data.Aeson.Types.Internal Methods traverse :: Applicative f => (a -> f b) -> Result a -> f ( Result b) Source # sequenceA :: Applicative f => Result (f a) -> f ( Result a) Source # mapM :: Monad m => (a -> m b) -> Result a -> m ( Result b) Source # sequence :: Monad m => Result (m a) -> m ( Result a) Source #
Traversable KeyMap
Instance details Defined in Data.Aeson.KeyMap Methods traverse :: Applicative f => (a -> f b) -> KeyMap a -> f ( KeyMap b) Source # sequenceA :: Applicative f => KeyMap (f a) -> f ( KeyMap a) Source # mapM :: Monad m => (a -> m b) -> KeyMap a -> m ( KeyMap b) Source # sequence :: Monad m => KeyMap (m a) -> m ( KeyMap a) Source #
Traversable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f ( Complex b) Source # sequenceA :: Applicative f => Complex (f a) -> f ( Complex a) Source # mapM :: Monad m => (a -> m b) -> Complex a -> m ( Complex b) Source # sequence :: Monad m => Complex (m a) -> m ( Complex a) Source #
Traversable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Min a -> f ( Min b) Source # sequenceA :: Applicative f => Min (f a) -> f ( Min a) Source # mapM :: Monad m => (a -> m b) -> Min a -> m ( Min b) Source # sequence :: Monad m => Min (m a) -> m ( Min a) Source #
Traversable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Max a -> f ( Max b) Source # sequenceA :: Applicative f => Max (f a) -> f ( Max a) Source # mapM :: Monad m => (a -> m b) -> Max a -> m ( Max b) Source # sequence :: Monad m => Max (m a) -> m ( Max a) Source #
Traversable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> First a -> f ( First b) Source # sequenceA :: Applicative f => First (f a) -> f ( First a) Source # mapM :: Monad m => (a -> m b) -> First a -> m ( First b) Source # sequence :: Monad m => First (m a) -> m ( First a) Source #
Traversable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Last a -> f ( Last b) Source # sequenceA :: Applicative f => Last (f a) -> f ( Last a) Source # mapM :: Monad m => (a -> m b) -> Last a -> m ( Last b) Source # sequence :: Monad m => Last (m a) -> m ( Last a) Source #
Traversable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Option a -> f ( Option b) Source # sequenceA :: Applicative f => Option (f a) -> f ( Option a) Source # mapM :: Monad m => (a -> m b) -> Option a -> m ( Option b) Source # sequence :: Monad m => Option (m a) -> m ( Option a) Source #
Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f ( ZipList b) Source # sequenceA :: Applicative f => ZipList (f a) -> f ( ZipList a) Source # mapM :: Monad m => (a -> m b) -> ZipList a -> m ( ZipList b) Source # sequence :: Monad m => ZipList (m a) -> m ( ZipList a) Source #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f ( Identity b) Source # sequenceA :: Applicative f => Identity (f a) -> f ( Identity a) Source # mapM :: Monad m => (a -> m b) -> Identity a -> m ( Identity b) Source # sequence :: Monad m => Identity (m a) -> m ( Identity a) Source #
Traversable First	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> First a -> f ( First b) Source # sequenceA :: Applicative f => First (f a) -> f ( First a) Source # mapM :: Monad m => (a -> m b) -> First a -> m ( First b) Source # sequence :: Monad m => First (m a) -> m ( First a) Source #
Traversable Last	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Last a -> f ( Last b) Source # sequenceA :: Applicative f => Last (f a) -> f ( Last a) Source # mapM :: Monad m => (a -> m b) -> Last a -> m ( Last b) Source # sequence :: Monad m => Last (m a) -> m ( Last a) Source #
Traversable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f ( Dual b) Source # sequenceA :: Applicative f => Dual (f a) -> f ( Dual a) Source # mapM :: Monad m => (a -> m b) -> Dual a -> m ( Dual b) Source # sequence :: Monad m => Dual (m a) -> m ( Dual a) Source #
Traversable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f ( Sum b) Source # sequenceA :: Applicative f => Sum (f a) -> f ( Sum a) Source # mapM :: Monad m => (a -> m b) -> Sum a -> m ( Sum b) Source # sequence :: Monad m => Sum (m a) -> m ( Sum a) Source #
Traversable Product	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Product a -> f ( Product b) Source # sequenceA :: Applicative f => Product (f a) -> f ( Product a) Source # mapM :: Monad m => (a -> m b) -> Product a -> m ( Product b) Source # sequence :: Monad m => Product (m a) -> m ( Product a) Source #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f ( Down b) Source # sequenceA :: Applicative f => Down (f a) -> f ( Down a) Source # mapM :: Monad m => (a -> m b) -> Down a -> m ( Down b) Source # sequence :: Monad m => Down (m a) -> m ( Down a) Source #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f ( NonEmpty b) Source # sequenceA :: Applicative f => NonEmpty (f a) -> f ( NonEmpty a) Source # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m ( NonEmpty b) Source # sequence :: Monad m => NonEmpty (m a) -> m ( NonEmpty a) Source #
Traversable IntMap	Traverses in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f ( IntMap b) Source # sequenceA :: Applicative f => IntMap (f a) -> f ( IntMap a) Source # mapM :: Monad m => (a -> m b) -> IntMap a -> m ( IntMap b) Source # sequence :: Monad m => IntMap (m a) -> m ( IntMap a) Source #
Traversable Tree
Instance details Defined in Data.Tree Methods traverse :: Applicative f => (a -> f b) -> Tree a -> f ( Tree b) Source # sequenceA :: Applicative f => Tree (f a) -> f ( Tree a) Source # mapM :: Monad m => (a -> m b) -> Tree a -> m ( Tree b) Source # sequence :: Monad m => Tree (m a) -> m ( Tree a) Source #
Traversable Seq
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f ( Seq b) Source # sequenceA :: Applicative f => Seq (f a) -> f ( Seq a) Source # mapM :: Monad m => (a -> m b) -> Seq a -> m ( Seq b) Source # sequence :: Monad m => Seq (m a) -> m ( Seq a) Source #
Traversable FingerTree
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> FingerTree a -> f ( FingerTree b) Source # sequenceA :: Applicative f => FingerTree (f a) -> f ( FingerTree a) Source # mapM :: Monad m => (a -> m b) -> FingerTree a -> m ( FingerTree b) Source # sequence :: Monad m => FingerTree (m a) -> m ( FingerTree a) Source #
Traversable Digit
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Digit a -> f ( Digit b) Source # sequenceA :: Applicative f => Digit (f a) -> f ( Digit a) Source # mapM :: Monad m => (a -> m b) -> Digit a -> m ( Digit b) Source # sequence :: Monad m => Digit (m a) -> m ( Digit a) Source #
Traversable Node
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Node a -> f ( Node b) Source # sequenceA :: Applicative f => Node (f a) -> f ( Node a) Source # mapM :: Monad m => (a -> m b) -> Node a -> m ( Node b) Source # sequence :: Monad m => Node (m a) -> m ( Node a) Source #
Traversable Elem
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Elem a -> f ( Elem b) Source # sequenceA :: Applicative f => Elem (f a) -> f ( Elem a) Source # mapM :: Monad m => (a -> m b) -> Elem a -> m ( Elem b) Source # sequence :: Monad m => Elem (m a) -> m ( Elem a) Source #
Traversable ViewL
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewL a -> f ( ViewL b) Source # sequenceA :: Applicative f => ViewL (f a) -> f ( ViewL a) Source # mapM :: Monad m => (a -> m b) -> ViewL a -> m ( ViewL b) Source # sequence :: Monad m => ViewL (m a) -> m ( ViewL a) Source #
Traversable ViewR
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewR a -> f ( ViewR b) Source # sequenceA :: Applicative f => ViewR (f a) -> f ( ViewR a) Source # mapM :: Monad m => (a -> m b) -> ViewR a -> m ( ViewR b) Source # sequence :: Monad m => ViewR (m a) -> m ( ViewR a) Source #
Traversable DList
Instance details Defined in Data.DList.Internal Methods traverse :: Applicative f => (a -> f b) -> DList a -> f ( DList b) Source # sequenceA :: Applicative f => DList (f a) -> f ( DList a) Source # mapM :: Monad m => (a -> m b) -> DList a -> m ( DList b) Source # sequence :: Monad m => DList (m a) -> m ( DList a) Source #
Traversable GenClosure
Instance details Defined in GHC.Exts.Heap.Closures Methods traverse :: Applicative f => (a -> f b) -> GenClosure a -> f ( GenClosure b) Source # sequenceA :: Applicative f => GenClosure (f a) -> f ( GenClosure a) Source # mapM :: Monad m => (a -> m b) -> GenClosure a -> m ( GenClosure b) Source # sequence :: Monad m => GenClosure (m a) -> m ( GenClosure a) Source #
Traversable SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods traverse :: Applicative f => (a -> f b) -> SmallArray a -> f ( SmallArray b) Source # sequenceA :: Applicative f => SmallArray (f a) -> f ( SmallArray a) Source # mapM :: Monad m => (a -> m b) -> SmallArray a -> m ( SmallArray b) Source # sequence :: Monad m => SmallArray (m a) -> m ( SmallArray a) Source #
Traversable Array
Instance details Defined in Data.Primitive.Array Methods traverse :: Applicative f => (a -> f b) -> Array a -> f ( Array b) Source # sequenceA :: Applicative f => Array (f a) -> f ( Array a) Source # mapM :: Monad m => (a -> m b) -> Array a -> m ( Array b) Source # sequence :: Monad m => Array (m a) -> m ( Array a) Source #
Traversable Maybe
Instance details Defined in Data.Strict.Maybe Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f ( Maybe b) Source # sequenceA :: Applicative f => Maybe (f a) -> f ( Maybe a) Source # mapM :: Monad m => (a -> m b) -> Maybe a -> m ( Maybe b) Source # sequence :: Monad m => Maybe (m a) -> m ( Maybe a) Source #
Traversable Vector
Instance details Defined in Data.Vector Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f ( Vector b) Source # sequenceA :: Applicative f => Vector (f a) -> f ( Vector a) Source # mapM :: Monad m => (a -> m b) -> Vector a -> m ( Vector b) Source # sequence :: Monad m => Vector (m a) -> m ( Vector a) Source #
Traversable ( Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f ( Either a b) Source # sequenceA :: Applicative f => Either a (f a0) -> f ( Either a a0) Source # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m ( Either a b) Source # sequence :: Monad m => Either a (m a0) -> m ( Either a a0) Source #
Traversable ( V1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f ( V1 b) Source # sequenceA :: Applicative f => V1 (f a) -> f ( V1 a) Source # mapM :: Monad m => (a -> m b) -> V1 a -> m ( V1 b) Source # sequence :: Monad m => V1 (m a) -> m ( V1 a) Source #
Traversable ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f ( U1 b) Source # sequenceA :: Applicative f => U1 (f a) -> f ( U1 a) Source # mapM :: Monad m => (a -> m b) -> U1 a -> m ( U1 b) Source # sequence :: Monad m => U1 (m a) -> m ( U1 a) Source #
Traversable ( UAddr :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f ( UAddr b) Source # sequenceA :: Applicative f => UAddr (f a) -> f ( UAddr a) Source # mapM :: Monad m => (a -> m b) -> UAddr a -> m ( UAddr b) Source # sequence :: Monad m => UAddr (m a) -> m ( UAddr a) Source #
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) Source # sequenceA :: Applicative f => UChar (f a) -> f ( UChar a) Source # mapM :: Monad m => (a -> m b) -> UChar a -> m ( UChar b) Source # sequence :: Monad m => UChar (m a) -> m ( UChar a) Source #
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) Source # sequenceA :: Applicative f => UDouble (f a) -> f ( UDouble a) Source # mapM :: Monad m => (a -> m b) -> UDouble a -> m ( UDouble b) Source # sequence :: Monad m => UDouble (m a) -> m ( UDouble a) Source #
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) Source # sequenceA :: Applicative f => UFloat (f a) -> f ( UFloat a) Source # mapM :: Monad m => (a -> m b) -> UFloat a -> m ( UFloat b) Source # sequence :: Monad m => UFloat (m a) -> m ( UFloat a) Source #
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) Source # sequenceA :: Applicative f => UInt (f a) -> f ( UInt a) Source # mapM :: Monad m => (a -> m b) -> UInt a -> m ( UInt b) Source # sequence :: Monad m => UInt (m a) -> m ( UInt a) Source #
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) Source # sequenceA :: Applicative f => UWord (f a) -> f ( UWord a) Source # mapM :: Monad m => (a -> m b) -> UWord a -> m ( UWord b) Source # sequence :: Monad m => UWord (m a) -> m ( UWord a) Source #
Traversable ( (,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> (a, a0) -> f (a, b) Source # sequenceA :: Applicative f => (a, f a0) -> f (a, a0) Source # mapM :: Monad m => (a0 -> m b) -> (a, a0) -> m (a, b) Source # sequence :: Monad m => (a, m a0) -> m (a, a0) Source #
Traversable ( Map k)	Traverses in order of increasing key.
Instance details Defined in Data.Map.Internal Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f ( Map k b) Source # sequenceA :: Applicative f => Map k (f a) -> f ( Map k a) Source # mapM :: Monad m => (a -> m b) -> Map k a -> m ( Map k b) Source # sequence :: Monad m => Map k (m a) -> m ( Map k a) Source #
Traversable ( HashMap k)
Instance details Defined in Data.HashMap.Internal Methods traverse :: Applicative f => (a -> f b) -> HashMap k a -> f ( HashMap k b) Source # sequenceA :: Applicative f => HashMap k (f a) -> f ( HashMap k a) Source # mapM :: Monad m => (a -> m b) -> HashMap k a -> m ( HashMap k b) Source # sequence :: Monad m => HashMap k (m a) -> m ( HashMap k a) Source #
Ix i => Traversable ( Array i)	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f ( Array i b) Source # sequenceA :: Applicative f => Array i (f a) -> f ( Array i a) Source # mapM :: Monad m => (a -> m b) -> Array i a -> m ( Array i b) Source # sequence :: Monad m => Array i (m a) -> m ( Array i a) Source #
Traversable ( Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a0 -> f b) -> Arg a a0 -> f ( Arg a b) Source # sequenceA :: Applicative f => Arg a (f a0) -> f ( Arg a a0) Source # mapM :: Monad m => (a0 -> m b) -> Arg a a0 -> m ( Arg a b) Source # sequence :: Monad m => Arg a (m a0) -> m ( Arg a a0) Source #
Traversable ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Proxy a -> f ( Proxy b) Source # sequenceA :: Applicative f => Proxy (f a) -> f ( Proxy a) Source # mapM :: Monad m => (a -> m b) -> Proxy a -> m ( Proxy b) Source # sequence :: Monad m => Proxy (m a) -> m ( Proxy a) Source #
Traversable f => Traversable ( ListT f)
Instance details Defined in Control.Monad.Trans.List Methods traverse :: Applicative f0 => (a -> f0 b) -> ListT f a -> f0 ( ListT f b) Source # sequenceA :: Applicative f0 => ListT f (f0 a) -> f0 ( ListT f a) Source # mapM :: Monad m => (a -> m b) -> ListT f a -> m ( ListT f b) Source # sequence :: Monad m => ListT f (m a) -> m ( ListT f a) Source #
Traversable ( These a)
Instance details Defined in Data.These Methods traverse :: Applicative f => (a0 -> f b) -> These a a0 -> f ( These a b) Source # sequenceA :: Applicative f => These a (f a0) -> f ( These a a0) Source # mapM :: Monad m => (a0 -> m b) -> These a a0 -> m ( These a b) Source # sequence :: Monad m => These a (m a0) -> m ( These a a0) Source #
Traversable ( Pair e)
Instance details Defined in Data.Strict.Tuple Methods traverse :: Applicative f => (a -> f b) -> Pair e a -> f ( Pair e b) Source # sequenceA :: Applicative f => Pair e (f a) -> f ( Pair e a) Source # mapM :: Monad m => (a -> m b) -> Pair e a -> m ( Pair e b) Source # sequence :: Monad m => Pair e (m a) -> m ( Pair e a) Source #
Traversable ( These a)
Instance details Defined in Data.Strict.These Methods traverse :: Applicative f => (a0 -> f b) -> These a a0 -> f ( These a b) Source # sequenceA :: Applicative f => These a (f a0) -> f ( These a a0) Source # mapM :: Monad m => (a0 -> m b) -> These a a0 -> m ( These a b) Source # sequence :: Monad m => These a (m a0) -> m ( These a a0) Source #
Traversable ( Either e)
Instance details Defined in Data.Strict.Either Methods traverse :: Applicative f => (a -> f b) -> Either e a -> f ( Either e b) Source # sequenceA :: Applicative f => Either e (f a) -> f ( Either e a) Source # mapM :: Monad m => (a -> m b) -> Either e a -> m ( Either e b) Source # sequence :: Monad m => Either e (m a) -> m ( Either e a) Source #
Traversable f => Traversable ( MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods traverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 ( MaybeT f b) Source # sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 ( MaybeT f a) Source # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m ( MaybeT f b) Source # sequence :: Monad m => MaybeT f (m a) -> m ( MaybeT f a) Source #
Traversable f => Traversable ( Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 ( Rec1 f b) Source # sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 ( Rec1 f a) Source # mapM :: Monad m => (a -> m b) -> Rec1 f a -> m ( Rec1 f b) Source # sequence :: Monad m => Rec1 f (m a) -> m ( Rec1 f a) Source #
Traversable ( Const m :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f ( Const m b) Source # sequenceA :: Applicative f => Const m (f a) -> f ( Const m a) Source # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 ( Const m b) Source # sequence :: Monad m0 => Const m (m0 a) -> m0 ( Const m a) Source #
Traversable f => Traversable ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Ap f a -> f0 ( Ap f b) Source # sequenceA :: Applicative f0 => Ap f (f0 a) -> f0 ( Ap f a) Source # mapM :: Monad m => (a -> m b) -> Ap f a -> m ( Ap f b) Source # sequence :: Monad m => Ap f (m a) -> m ( Ap f a) Source #
Traversable f => Traversable ( Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 ( Alt f b) Source # sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 ( Alt f a) Source # mapM :: Monad m => (a -> m b) -> Alt f a -> m ( Alt f b) Source # sequence :: Monad m => Alt f (m a) -> m ( Alt f a) Source #
Traversable f => Traversable ( IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods traverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 ( IdentityT f b) Source # sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 ( IdentityT f a) Source # mapM :: Monad m => (a -> m b) -> IdentityT f a -> m ( IdentityT f b) Source # sequence :: Monad m => IdentityT f (m a) -> m ( IdentityT f a) Source #
Traversable f => Traversable ( ErrorT e f)
Instance details Defined in Control.Monad.Trans.Error Methods traverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 ( ErrorT e f b) Source # sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 ( ErrorT e f a) Source # mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m ( ErrorT e f b) Source # sequence :: Monad m => ErrorT e f (m a) -> m ( ErrorT e f a) Source #
Traversable f => Traversable ( ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods traverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 ( ExceptT e f b) Source # sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 ( ExceptT e f a) Source # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m ( ExceptT e f b) Source # sequence :: Monad m => ExceptT e f (m a) -> m ( ExceptT e f a) Source #
Traversable f => Traversable ( WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods traverse :: Applicative f0 => (a -> f0 b) -> WriterT w f a -> f0 ( WriterT w f b) Source # sequenceA :: Applicative f0 => WriterT w f (f0 a) -> f0 ( WriterT w f a) Source # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m ( WriterT w f b) Source # sequence :: Monad m => WriterT w f (m a) -> m ( WriterT w f a) Source #
Traversable f => Traversable ( WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods traverse :: Applicative f0 => (a -> f0 b) -> WriterT w f a -> f0 ( WriterT w f b) Source # sequenceA :: Applicative f0 => WriterT w f (f0 a) -> f0 ( WriterT w f a) Source # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m ( WriterT w f b) Source # sequence :: Monad m => WriterT w f (m a) -> m ( WriterT w f a) Source #
Traversable ( Tagged s)
Instance details Defined in Data.Tagged Methods traverse :: Applicative f => (a -> f b) -> Tagged s a -> f ( Tagged s b) Source # sequenceA :: Applicative f => Tagged s (f a) -> f ( Tagged s a) Source # mapM :: Monad m => (a -> m b) -> Tagged s a -> m ( Tagged s b) Source # sequence :: Monad m => Tagged s (m a) -> m ( Tagged s a) Source #
( Traversable f, Traversable g) => Traversable ( These1 f g)
Instance details Defined in Data.Functor.These Methods traverse :: Applicative f0 => (a -> f0 b) -> These1 f g a -> f0 ( These1 f g b) Source # sequenceA :: Applicative f0 => These1 f g (f0 a) -> f0 ( These1 f g a) Source # mapM :: Monad m => (a -> m b) -> These1 f g a -> m ( These1 f g b) Source # sequence :: Monad m => These1 f g (m a) -> m ( These1 f g a) Source #
Traversable ( K1 i c :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f ( K1 i c b) Source # sequenceA :: Applicative f => K1 i c (f a) -> f ( K1 i c a) Source # mapM :: Monad m => (a -> m b) -> K1 i c a -> m ( K1 i c b) Source # sequence :: Monad m => K1 i c (m a) -> m ( K1 i c a) Source #
( Traversable f, Traversable g) => Traversable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) Source # sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) Source # sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) Source #
( Traversable f, Traversable g) => Traversable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) Source # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((f :: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) Source # sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a) Source #
( Traversable f, Traversable g) => Traversable ( Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods traverse :: Applicative f0 => (a -> f0 b) -> Product f g a -> f0 ( Product f g b) Source # sequenceA :: Applicative f0 => Product f g (f0 a) -> f0 ( Product f g a) Source # mapM :: Monad m => (a -> m b) -> Product f g a -> m ( Product f g b) Source # sequence :: Monad m => Product f g (m a) -> m ( Product f g a) Source #
( Traversable f, Traversable g) => Traversable ( Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods traverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 ( Sum f g b) Source # sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 ( Sum f g a) Source # mapM :: Monad m => (a -> m b) -> Sum f g a -> m ( Sum f g b) Source # sequence :: Monad m => Sum f g (m a) -> m ( Sum f g a) Source #
Traversable f => Traversable ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 ( M1 i c f b) Source # sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 ( M1 i c f a) Source # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m ( M1 i c f b) Source # sequence :: Monad m => M1 i c f (m a) -> m ( M1 i c f a) Source #
( Traversable f, Traversable g) => Traversable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) Source # sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) Source # sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) Source #
( Traversable f, Traversable g) => Traversable ( Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 ( Compose f g b) Source # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 ( Compose f g a) Source # mapM :: Monad m => (a -> m b) -> Compose f g a -> m ( Compose f g b) Source # sequence :: Monad m => Compose f g (m a) -> m ( Compose f g a) Source #
Bitraversable p => Traversable ( Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods traverse :: Applicative f => (a0 -> f b) -> Flip p a a0 -> f ( Flip p a b) Source # sequenceA :: Applicative f => Flip p a (f a0) -> f ( Flip p a a0) Source # mapM :: Monad m => (a0 -> m b) -> Flip p a a0 -> m ( Flip p a b) Source # sequence :: Monad m => Flip p a (m a0) -> m ( Flip p a a0) Source #
( Traversable (f a), Traversable (g a)) => Traversable ( Sum f g a)
Instance details Defined in Data.Bifunctor.Sum Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Sum f g a a0 -> f0 ( Sum f g a b) Source # sequenceA :: Applicative f0 => Sum f g a (f0 a0) -> f0 ( Sum f g a a0) Source # mapM :: Monad m => (a0 -> m b) -> Sum f g a a0 -> m ( Sum f g a b) Source # sequence :: Monad m => Sum f g a (m a0) -> m ( Sum f g a a0) Source #
( Traversable (f a), Traversable (g a)) => Traversable ( Product f g a)
Instance details Defined in Data.Bifunctor.Product Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Product f g a a0 -> f0 ( Product f g a b) Source # sequenceA :: Applicative f0 => Product f g a (f0 a0) -> f0 ( Product f g a a0) Source # mapM :: Monad m => (a0 -> m b) -> Product f g a a0 -> m ( Product f g a b) Source # sequence :: Monad m => Product f g a (m a0) -> m ( Product f g a a0) Source #
( Traversable f, Bitraversable p) => Traversable ( Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Tannen f p a a0 -> f0 ( Tannen f p a b) Source # sequenceA :: Applicative f0 => Tannen f p a (f0 a0) -> f0 ( Tannen f p a a0) Source # mapM :: Monad m => (a0 -> m b) -> Tannen f p a a0 -> m ( Tannen f p a b) Source # sequence :: Monad m => Tannen f p a (m a0) -> m ( Tannen f p a a0) Source #
( Bitraversable p, Traversable g) => Traversable ( Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Biff p f g a a0 -> f0 ( Biff p f g a b) Source # sequenceA :: Applicative f0 => Biff p f g a (f0 a0) -> f0 ( Biff p f g a a0) Source # mapM :: Monad m => (a0 -> m b) -> Biff p f g a a0 -> m ( Biff p f g a b) Source # sequence :: Monad m => Biff p f g a (m a0) -> m ( Biff p f g a a0) Source #

class Generic a where Source #

Representable types of kind * . This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Associated Types

type Rep a :: Type -> Type Source #

Generic representation type

Methods

from :: a -> Rep a x Source #

Convert from the datatype to its representation

to :: Rep a x -> a Source #

Convert from the representation to the datatype

Instances

Instances details

Generic Bool	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type Source # Methods from :: Bool -> Rep Bool x Source # to :: Rep Bool x -> Bool Source #
Generic Ordering	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type Source # Methods from :: Ordering -> Rep Ordering x Source # to :: Rep Ordering x -> Ordering Source #
Generic Exp
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type Source # Methods from :: Exp -> Rep Exp x Source # to :: Rep Exp x -> Exp Source #
Generic Match
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type Source # Methods from :: Match -> Rep Match x Source # to :: Rep Match x -> Match Source #
Generic Clause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type Source # Methods from :: Clause -> Rep Clause x Source # to :: Rep Clause x -> Clause Source #
Generic Pat
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type Source # Methods from :: Pat -> Rep Pat x Source # to :: Rep Pat x -> Pat Source #
Generic Type
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type Source # Methods from :: Type -> Rep Type x Source # to :: Rep Type x -> Type Source #
Generic Dec
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type Source # Methods from :: Dec -> Rep Dec x Source # to :: Rep Dec x -> Dec Source #
Generic Name
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type Source # Methods from :: Name -> Rep Name x Source # to :: Rep Name x -> Name Source #
Generic FunDep
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type Source # Methods from :: FunDep -> Rep FunDep x Source # to :: Rep FunDep x -> FunDep Source #
Generic InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type Source # Methods from :: InjectivityAnn -> Rep InjectivityAnn x Source # to :: Rep InjectivityAnn x -> InjectivityAnn Source #
Generic Overlap
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Overlap :: Type -> Type Source # Methods from :: Overlap -> Rep Overlap x Source # to :: Rep Overlap x -> Overlap Source #
Generic ()	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type Source # Methods from :: () -> Rep () x Source # to :: Rep () x -> () Source #
Generic Value
Instance details Defined in Data.Aeson.Types.Internal Associated Types type Rep Value :: Type -> Type Source # Methods from :: Value -> Rep Value x Source # to :: Rep Value x -> Value Source #
Generic Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type Source # Methods from :: Void -> Rep Void x Source # to :: Rep Void x -> Void Source #
Generic Version	Since: base-4.9.0.0
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type Source # Methods from :: Version -> Rep Version x Source # to :: Rep Version x -> Version Source #
Generic ExitCode
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type Source # Methods from :: ExitCode -> Rep ExitCode x Source # to :: Rep ExitCode x -> ExitCode Source #
Generic All	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type Source # Methods from :: All -> Rep All x Source # to :: Rep All x -> All Source #
Generic Any	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type Source # Methods from :: Any -> Rep Any x Source # to :: Rep Any x -> Any Source #
Generic Fixity	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
Generic Associativity	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type Source # Methods from :: Associativity -> Rep Associativity x Source # to :: Rep Associativity x -> Associativity Source #
Generic SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Generic SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Generic DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Generic Extension
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type Source # Methods from :: Extension -> Rep Extension x Source # to :: Rep Extension x -> Extension Source #
Generic ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type Source # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x Source # to :: Rep ForeignSrcLang x -> ForeignSrcLang Source #
Generic PrimType
Instance details Defined in GHC.Exts.Heap.Closures Associated Types type Rep PrimType :: Type -> Type Source # Methods from :: PrimType -> Rep PrimType x Source # to :: Rep PrimType x -> PrimType Source #
Generic StgInfoTable
Instance details Defined in GHC.Exts.Heap.InfoTable.Types Associated Types type Rep StgInfoTable :: Type -> Type Source # Methods from :: StgInfoTable -> Rep StgInfoTable x Source # to :: Rep StgInfoTable x -> StgInfoTable Source #
Generic ClosureType
Instance details Defined in GHC.Exts.Heap.ClosureTypes Associated Types type Rep ClosureType :: Type -> Type Source # Methods from :: ClosureType -> Rep ClosureType x Source # to :: Rep ClosureType x -> ClosureType Source #
Generic Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Associated Types type Rep Doc :: Type -> Type Source # Methods from :: Doc -> Rep Doc x Source # to :: Rep Doc x -> Doc Source #
Generic TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep TextDetails :: Type -> Type Source # Methods from :: TextDetails -> Rep TextDetails x Source # to :: Rep TextDetails x -> TextDetails Source #
Generic Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Style :: Type -> Type Source # Methods from :: Style -> Rep Style x Source # to :: Rep Style x -> Style Source #
Generic Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Mode :: Type -> Type Source # Methods from :: Mode -> Rep Mode x Source # to :: Rep Mode x -> Mode Source #
Generic ModName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModName :: Type -> Type Source # Methods from :: ModName -> Rep ModName x Source # to :: Rep ModName x -> ModName Source #
Generic PkgName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PkgName :: Type -> Type Source # Methods from :: PkgName -> Rep PkgName x Source # to :: Rep PkgName x -> PkgName Source #
Generic Module
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Module :: Type -> Type Source # Methods from :: Module -> Rep Module x Source # to :: Rep Module x -> Module Source #
Generic OccName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep OccName :: Type -> Type Source # Methods from :: OccName -> Rep OccName x Source # to :: Rep OccName x -> OccName Source #
Generic NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameFlavour :: Type -> Type Source # Methods from :: NameFlavour -> Rep NameFlavour x Source # to :: Rep NameFlavour x -> NameFlavour Source #
Generic NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type Source # Methods from :: NameSpace -> Rep NameSpace x Source # to :: Rep NameSpace x -> NameSpace Source #
Generic Loc
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type Source # Methods from :: Loc -> Rep Loc x Source # to :: Rep Loc x -> Loc Source #
Generic Info
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type Source # Methods from :: Info -> Rep Info x Source # to :: Rep Info x -> Info Source #
Generic ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type Source # Methods from :: ModuleInfo -> Rep ModuleInfo x Source # to :: Rep ModuleInfo x -> ModuleInfo Source #
Generic Fixity
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
Generic FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type Source # Methods from :: FixityDirection -> Rep FixityDirection x Source # to :: Rep FixityDirection x -> FixityDirection Source #
Generic Lit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type Source # Methods from :: Lit -> Rep Lit x Source # to :: Rep Lit x -> Lit Source #
Generic Bytes
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bytes :: Type -> Type Source # Methods from :: Bytes -> Rep Bytes x Source # to :: Rep Bytes x -> Bytes Source #
Generic Body
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type Source # Methods from :: Body -> Rep Body x Source # to :: Rep Body x -> Body Source #
Generic Guard
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type Source # Methods from :: Guard -> Rep Guard x Source # to :: Rep Guard x -> Guard Source #
Generic Stmt
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type Source # Methods from :: Stmt -> Rep Stmt x Source # to :: Rep Stmt x -> Stmt Source #
Generic Range
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type Source # Methods from :: Range -> Rep Range x Source # to :: Rep Range x -> Range Source #
Generic DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivClause :: Type -> Type Source # Methods from :: DerivClause -> Rep DerivClause x Source # to :: Rep DerivClause x -> DerivClause Source #
Generic DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivStrategy :: Type -> Type Source # Methods from :: DerivStrategy -> Rep DerivStrategy x Source # to :: Rep DerivStrategy x -> DerivStrategy Source #
Generic TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type Source # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x Source # to :: Rep TypeFamilyHead x -> TypeFamilyHead Source #
Generic TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type Source # Methods from :: TySynEqn -> Rep TySynEqn x Source # to :: Rep TySynEqn x -> TySynEqn Source #
Generic Foreign
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type Source # Methods from :: Foreign -> Rep Foreign x Source # to :: Rep Foreign x -> Foreign Source #
Generic Callconv
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type Source # Methods from :: Callconv -> Rep Callconv x Source # to :: Rep Callconv x -> Callconv Source #
Generic Safety
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type Source # Methods from :: Safety -> Rep Safety x Source # to :: Rep Safety x -> Safety Source #
Generic Pragma
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type Source # Methods from :: Pragma -> Rep Pragma x Source # to :: Rep Pragma x -> Pragma Source #
Generic Inline
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type Source # Methods from :: Inline -> Rep Inline x Source # to :: Rep Inline x -> Inline Source #
Generic RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type Source # Methods from :: RuleMatch -> Rep RuleMatch x Source # to :: Rep RuleMatch x -> RuleMatch Source #
Generic Phases
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type Source # Methods from :: Phases -> Rep Phases x Source # to :: Rep Phases x -> Phases Source #
Generic RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type Source # Methods from :: RuleBndr -> Rep RuleBndr x Source # to :: Rep RuleBndr x -> RuleBndr Source #
Generic AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type Source # Methods from :: AnnTarget -> Rep AnnTarget x Source # to :: Rep AnnTarget x -> AnnTarget Source #
Generic SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Generic SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Generic DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Generic Con
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type Source # Methods from :: Con -> Rep Con x Source # to :: Rep Con x -> Con Source #
Generic Bang
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type Source # Methods from :: Bang -> Rep Bang x Source # to :: Rep Bang x -> Bang Source #
Generic PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type Source # Methods from :: PatSynDir -> Rep PatSynDir x Source # to :: Rep PatSynDir x -> PatSynDir Source #
Generic PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type Source # Methods from :: PatSynArgs -> Rep PatSynArgs x Source # to :: Rep PatSynArgs x -> PatSynArgs Source #
Generic TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyVarBndr :: Type -> Type Source # Methods from :: TyVarBndr -> Rep TyVarBndr x Source # to :: Rep TyVarBndr x -> TyVarBndr Source #
Generic FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type Source # Methods from :: FamilyResultSig -> Rep FamilyResultSig x Source # to :: Rep FamilyResultSig x -> FamilyResultSig Source #
Generic TyLit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type Source # Methods from :: TyLit -> Rep TyLit x Source # to :: Rep TyLit x -> TyLit Source #
Generic Role
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type Source # Methods from :: Role -> Rep Role x Source # to :: Rep Role x -> Role Source #
Generic AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type Source # Methods from :: AnnLookup -> Rep AnnLookup x Source # to :: Rep AnnLookup x -> AnnLookup Source #
Generic [a]	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type Source # Methods from :: [a] -> Rep [a] x Source # to :: Rep [a] x -> [a] Source #
Generic ( Maybe a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Maybe a) :: Type -> Type Source # Methods from :: Maybe a -> Rep ( Maybe a) x Source # to :: Rep ( Maybe a) x -> Maybe a Source #
Generic ( Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Par1 p) :: Type -> Type Source # Methods from :: Par1 p -> Rep ( Par1 p) x Source # to :: Rep ( Par1 p) x -> Par1 p Source #
Generic ( Solo a)
Instance details Defined in Data.Tuple.Solo Associated Types type Rep ( Solo a) :: Type -> Type Source # Methods from :: Solo a -> Rep ( Solo a) x Source # to :: Rep ( Solo a) x -> Solo a Source #
Generic ( Complex a)	Since: base-4.9.0.0
Instance details Defined in Data.Complex Associated Types type Rep ( Complex a) :: Type -> Type Source # Methods from :: Complex a -> Rep ( Complex a) x Source # to :: Rep ( Complex a) x -> Complex a Source #
Generic ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( Min a) :: Type -> Type Source # Methods from :: Min a -> Rep ( Min a) x Source # to :: Rep ( Min a) x -> Min a Source #
Generic ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( Max a) :: Type -> Type Source # Methods from :: Max a -> Rep ( Max a) x Source # to :: Rep ( Max a) x -> Max a Source #
Generic ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( First a) :: Type -> Type Source # Methods from :: First a -> Rep ( First a) x Source # to :: Rep ( First a) x -> First a Source #
Generic ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( Last a) :: Type -> Type Source # Methods from :: Last a -> Rep ( Last a) x Source # to :: Rep ( Last a) x -> Last a Source #
Generic ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( WrappedMonoid m) :: Type -> Type Source # Methods from :: WrappedMonoid m -> Rep ( WrappedMonoid m) x Source # to :: Rep ( WrappedMonoid m) x -> WrappedMonoid m Source #
Generic ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( Option a) :: Type -> Type Source # Methods from :: Option a -> Rep ( Option a) x Source # to :: Rep ( Option a) x -> Option a Source #
Generic ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep ( ZipList a) :: Type -> Type Source # Methods from :: ZipList a -> Rep ( ZipList a) x Source # to :: Rep ( ZipList a) x -> ZipList a Source #
Generic ( Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Associated Types type Rep ( Identity a) :: Type -> Type Source # Methods from :: Identity a -> Rep ( Identity a) x Source # to :: Rep ( Identity a) x -> Identity a Source #
Generic ( First a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep ( First a) :: Type -> Type Source # Methods from :: First a -> Rep ( First a) x Source # to :: Rep ( First a) x -> First a Source #
Generic ( Last a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep ( Last a) :: Type -> Type Source # Methods from :: Last a -> Rep ( Last a) x Source # to :: Rep ( Last a) x -> Last a Source #
Generic ( Dual a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Dual a) :: Type -> Type Source # Methods from :: Dual a -> Rep ( Dual a) x Source # to :: Rep ( Dual a) x -> Dual a Source #
Generic ( Endo a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Endo a) :: Type -> Type Source # Methods from :: Endo a -> Rep ( Endo a) x Source # to :: Rep ( Endo a) x -> Endo a Source #
Generic ( Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Sum a) :: Type -> Type Source # Methods from :: Sum a -> Rep ( Sum a) x Source # to :: Rep ( Sum a) x -> Sum a Source #
Generic ( Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Product a) :: Type -> Type Source # Methods from :: Product a -> Rep ( Product a) x Source # to :: Rep ( Product a) x -> Product a Source #
Generic ( Down a)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Down a) :: Type -> Type Source # Methods from :: Down a -> Rep ( Down a) x Source # to :: Rep ( Down a) x -> Down a Source #
Generic ( NonEmpty a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( NonEmpty a) :: Type -> Type Source # Methods from :: NonEmpty a -> Rep ( NonEmpty a) x Source # to :: Rep ( NonEmpty a) x -> NonEmpty a Source #
Generic ( Tree a)	Since: containers-0.5.8
Instance details Defined in Data.Tree Associated Types type Rep ( Tree a) :: Type -> Type Source # Methods from :: Tree a -> Rep ( Tree a) x Source # to :: Rep ( Tree a) x -> Tree a Source #
Generic ( FingerTree a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep ( FingerTree a) :: Type -> Type Source # Methods from :: FingerTree a -> Rep ( FingerTree a) x Source # to :: Rep ( FingerTree a) x -> FingerTree a Source #
Generic ( Digit a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep ( Digit a) :: Type -> Type Source # Methods from :: Digit a -> Rep ( Digit a) x Source # to :: Rep ( Digit a) x -> Digit a Source #
Generic ( Node a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep ( Node a) :: Type -> Type Source # Methods from :: Node a -> Rep ( Node a) x Source # to :: Rep ( Node a) x -> Node a Source #
Generic ( Elem a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep ( Elem a) :: Type -> Type Source # Methods from :: Elem a -> Rep ( Elem a) x Source # to :: Rep ( Elem a) x -> Elem a Source #
Generic ( ViewL a)	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep ( ViewL a) :: Type -> Type Source # Methods from :: ViewL a -> Rep ( ViewL a) x Source # to :: Rep ( ViewL a) x -> ViewL a Source #
Generic ( ViewR a)	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep ( ViewR a) :: Type -> Type Source # Methods from :: ViewR a -> Rep ( ViewR a) x Source # to :: Rep ( ViewR a) x -> ViewR a Source #
Generic ( Fix f)
Instance details Defined in Data.Fix Associated Types type Rep ( Fix f) :: Type -> Type Source # Methods from :: Fix f -> Rep ( Fix f) x Source # to :: Rep ( Fix f) x -> Fix f Source #
Generic ( GenClosure b)
Instance details Defined in GHC.Exts.Heap.Closures Associated Types type Rep ( GenClosure b) :: Type -> Type Source # Methods from :: GenClosure b -> Rep ( GenClosure b) x Source # to :: Rep ( GenClosure b) x -> GenClosure b Source #
Generic ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep ( Doc a) :: Type -> Type Source # Methods from :: Doc a -> Rep ( Doc a) x Source # to :: Rep ( Doc a) x -> Doc a Source #
Generic ( Maybe a)
Instance details Defined in Data.Strict.Maybe Associated Types type Rep ( Maybe a) :: Type -> Type Source # Methods from :: Maybe a -> Rep ( Maybe a) x Source # to :: Rep ( Maybe a) x -> Maybe a Source #
Generic ( Either a b)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Either a b) :: Type -> Type Source # Methods from :: Either a b -> Rep ( Either a b) x Source # to :: Rep ( Either a b) x -> Either a b Source #
Generic ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( V1 p) :: Type -> Type Source # Methods from :: V1 p -> Rep ( V1 p) x Source # to :: Rep ( V1 p) x -> V1 p Source #
Generic ( U1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( U1 p) :: Type -> Type Source # Methods from :: U1 p -> Rep ( U1 p) x Source # to :: Rep ( U1 p) x -> U1 p Source #
Generic (a, b)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type Source # Methods from :: (a, b) -> Rep (a, b) x Source # to :: Rep (a, b) x -> (a, b) Source #
Generic ( Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( Arg a b) :: Type -> Type Source # Methods from :: Arg a b -> Rep ( Arg a b) x Source # to :: Rep ( Arg a b) x -> Arg a b Source #
Generic ( WrappedMonad m a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep ( WrappedMonad m a) :: Type -> Type Source # Methods from :: WrappedMonad m a -> Rep ( WrappedMonad m a) x Source # to :: Rep ( WrappedMonad m a) x -> WrappedMonad m a Source #
Generic ( Proxy t)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Proxy t) :: Type -> Type Source # Methods from :: Proxy t -> Rep ( Proxy t) x Source # to :: Rep ( Proxy t) x -> Proxy t Source #
Generic ( These a b)
Instance details Defined in Data.These Associated Types type Rep ( These a b) :: Type -> Type Source # Methods from :: These a b -> Rep ( These a b) x Source # to :: Rep ( These a b) x -> These a b Source #
Generic ( Pair a b)
Instance details Defined in Data.Strict.Tuple Associated Types type Rep ( Pair a b) :: Type -> Type Source # Methods from :: Pair a b -> Rep ( Pair a b) x Source # to :: Rep ( Pair a b) x -> Pair a b Source #
Generic ( These a b)
Instance details Defined in Data.Strict.These Associated Types type Rep ( These a b) :: Type -> Type Source # Methods from :: These a b -> Rep ( These a b) x Source # to :: Rep ( These a b) x -> These a b Source #
Generic ( Either a b)
Instance details Defined in Data.Strict.Either Associated Types type Rep ( Either a b) :: Type -> Type Source # Methods from :: Either a b -> Rep ( Either a b) x Source # to :: Rep ( Either a b) x -> Either a b Source #
Generic ( Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Rec1 f p) :: Type -> Type Source # Methods from :: Rec1 f p -> Rep ( Rec1 f p) x Source # to :: Rep ( Rec1 f p) x -> Rec1 f p Source #
Generic ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec ( Ptr ()) p) :: Type -> Type Source # Methods from :: URec ( Ptr ()) p -> Rep ( URec ( Ptr ()) p) x Source # to :: Rep ( URec ( Ptr ()) p) x -> URec ( Ptr ()) p Source #
Generic ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep ( URec Char p) x Source # to :: Rep ( URec Char p) x -> URec Char p Source #
Generic ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep ( URec Double p) x Source # to :: Rep ( URec Double p) x -> URec Double p Source #
Generic ( URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep ( URec Float p) x Source # to :: Rep ( URec Float p) x -> URec Float p Source #
Generic ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep ( URec Int p) x Source # to :: Rep ( URec Int p) x -> URec Int p Source #
Generic ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep ( URec Word p) x Source # to :: Rep ( URec Word p) x -> URec Word p Source #
Generic (a, b, c)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type Source # Methods from :: (a, b, c) -> Rep (a, b, c) x Source # to :: Rep (a, b, c) x -> (a, b, c) Source #
Generic ( WrappedArrow a b c)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep ( WrappedArrow a b c) :: Type -> Type Source # Methods from :: WrappedArrow a b c -> Rep ( WrappedArrow a b c) x Source # to :: Rep ( WrappedArrow a b c) x -> WrappedArrow a b c Source #
Generic ( Kleisli m a b)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Associated Types type Rep ( Kleisli m a b) :: Type -> Type Source # Methods from :: Kleisli m a b -> Rep ( Kleisli m a b) x Source # to :: Rep ( Kleisli m a b) x -> Kleisli m a b Source #
Generic ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Associated Types type Rep ( Const a b) :: Type -> Type Source # Methods from :: Const a b -> Rep ( Const a b) x Source # to :: Rep ( Const a b) x -> Const a b Source #
Generic ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Associated Types type Rep ( Ap f a) :: Type -> Type Source # Methods from :: Ap f a -> Rep ( Ap f a) x Source # to :: Rep ( Ap f a) x -> Ap f a Source #
Generic ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Alt f a) :: Type -> Type Source # Methods from :: Alt f a -> Rep ( Alt f a) x Source # to :: Rep ( Alt f a) x -> Alt f a Source #
Generic ( Tagged s b)
Instance details Defined in Data.Tagged Associated Types type Rep ( Tagged s b) :: Type -> Type Source # Methods from :: Tagged s b -> Rep ( Tagged s b) x Source # to :: Rep ( Tagged s b) x -> Tagged s b Source #
Generic ( These1 f g a)
Instance details Defined in Data.Functor.These Associated Types type Rep ( These1 f g a) :: Type -> Type Source # Methods from :: These1 f g a -> Rep ( These1 f g a) x Source # to :: Rep ( These1 f g a) x -> These1 f g a Source #
Generic ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( K1 i c p) :: Type -> Type Source # Methods from :: K1 i c p -> Rep ( K1 i c p) x Source # to :: Rep ( K1 i c p) x -> K1 i c p Source #
Generic ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type Source # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x Source # to :: Rep ((f :+: g) p) x -> (f :+: g) p Source #
Generic ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type Source # Methods from :: (f :: g) p -> Rep ((f :: g) p) x Source # to :: Rep ((f :: g) p) x -> (f :*: g) p Source #
Generic (a, b, c, d)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type Source # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x Source # to :: Rep (a, b, c, d) x -> (a, b, c, d) Source #
Generic ( Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Associated Types type Rep ( Product f g a) :: Type -> Type Source # Methods from :: Product f g a -> Rep ( Product f g a) x Source # to :: Rep ( Product f g a) x -> Product f g a Source #
Generic ( Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Associated Types type Rep ( Sum f g a) :: Type -> Type Source # Methods from :: Sum f g a -> Rep ( Sum f g a) x Source # to :: Rep ( Sum f g a) x -> Sum f g a Source #
Generic ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( M1 i c f p) :: Type -> Type Source # Methods from :: M1 i c f p -> Rep ( M1 i c f p) x Source # to :: Rep ( M1 i c f p) x -> M1 i c f p Source #
Generic ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type Source # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x Source # to :: Rep ((f :.: g) p) x -> (f :.: g) p Source #
Generic (a, b, c, d, e)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type Source # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x Source # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) Source #
Generic ( Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Associated Types type Rep ( Compose f g a) :: Type -> Type Source # Methods from :: Compose f g a -> Rep ( Compose f g a) x Source # to :: Rep ( Compose f g a) x -> Compose f g a Source #
Generic ( Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Associated Types type Rep ( Flip p a b) :: Type -> Type Source # Methods from :: Flip p a b -> Rep ( Flip p a b) x Source # to :: Rep ( Flip p a b) x -> Flip p a b Source #
Generic (a, b, c, d, e, f)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x Source # to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) Source #
Generic ( Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep ( Sum p q a b) :: Type -> Type Source # Methods from :: Sum p q a b -> Rep ( Sum p q a b) x Source # to :: Rep ( Sum p q a b) x -> Sum p q a b Source #
Generic ( Product f g a b)
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep ( Product f g a b) :: Type -> Type Source # Methods from :: Product f g a b -> Rep ( Product f g a b) x Source # to :: Rep ( Product f g a b) x -> Product f g a b Source #
Generic (a, b, c, d, e, f, g)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x Source # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) Source #
Generic ( Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep ( Tannen f p a b) :: Type -> Type Source # Methods from :: Tannen f p a b -> Rep ( Tannen f p a b) x Source # to :: Rep ( Tannen f p a b) x -> Tannen f p a b Source #
Generic ( Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Associated Types type Rep ( Biff p f g a b) :: Type -> Type Source # Methods from :: Biff p f g a b -> Rep ( Biff p f g a b) x Source # to :: Rep ( Biff p f g a b) x -> Biff p f g a b Source #

class Generic1 (f :: k -> Type ) Source #

Representable types of kind * -> * (or kind k -> * , when PolyKinds is enabled). This class is derivable in GHC with the DeriveGeneric flag on.

A Generic1 instance must satisfy the following laws:

from1 . to1 ≡ id
to1 . from1 ≡ id

Minimal complete definition

from1 , to1

Instances

Instances details

Generic1 ( V1 :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 V1 :: k -> Type Source # Methods from1 :: forall (a :: k0). V1 a -> Rep1 V1 a Source # to1 :: forall (a :: k0). Rep1 V1 a -> V1 a Source #
Generic1 ( U1 :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 U1 :: k -> Type Source # Methods from1 :: forall (a :: k0). U1 a -> Rep1 U1 a Source # to1 :: forall (a :: k0). Rep1 U1 a -> U1 a Source #
Generic1 ( Proxy :: k -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Proxy :: k -> Type Source # Methods from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a Source # to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a Source #
Generic1 ( Const a :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Associated Types type Rep1 ( Const a) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). Const a a0 -> Rep1 ( Const a) a0 Source # to1 :: forall (a0 :: k0). Rep1 ( Const a) a0 -> Const a a0 Source #
Generic1 ( Ap f :: k -> Type )	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 ( Ap f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Ap f a -> Rep1 ( Ap f) a Source # to1 :: forall (a :: k0). Rep1 ( Ap f) a -> Ap f a Source #
Generic1 ( Alt f :: k -> Type )	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 ( Alt f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Alt f a -> Rep1 ( Alt f) a Source # to1 :: forall (a :: k0). Rep1 ( Alt f) a -> Alt f a Source #
Generic1 ( URec ( Ptr ()) :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec ( Ptr ())) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec ( Ptr ()) a -> Rep1 ( URec ( Ptr ())) a Source # to1 :: forall (a :: k0). Rep1 ( URec ( Ptr ())) a -> URec ( Ptr ()) a Source #
Generic1 ( URec Char :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Char ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 ( URec Char ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Char ) a -> URec Char a Source #
Generic1 ( URec Double :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Double ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 ( URec Double ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Double ) a -> URec Double a Source #
Generic1 ( URec Float :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Float ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 ( URec Float ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Float ) a -> URec Float a Source #
Generic1 ( URec Int :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Int ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 ( URec Int ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Int ) a -> URec Int a Source #
Generic1 ( URec Word :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Word ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 ( URec Word ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Word ) a -> URec Word a Source #
Generic1 ( Rec1 f :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( Rec1 f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Rec1 f a -> Rep1 ( Rec1 f) a Source # to1 :: forall (a :: k0). Rep1 ( Rec1 f) a -> Rec1 f a Source #
Generic1 ( Sum f g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Associated Types type Rep1 ( Sum f g) :: k -> Type Source # Methods from1 :: forall (a :: k0). Sum f g a -> Rep1 ( Sum f g) a Source # to1 :: forall (a :: k0). Rep1 ( Sum f g) a -> Sum f g a Source #
Generic1 ( Product f g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Associated Types type Rep1 ( Product f g) :: k -> Type Source # Methods from1 :: forall (a :: k0). Product f g a -> Rep1 ( Product f g) a Source # to1 :: forall (a :: k0). Rep1 ( Product f g) a -> Product f g a Source #
Generic1 ( K1 i c :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( K1 i c) :: k -> Type Source # Methods from1 :: forall (a :: k0). K1 i c a -> Rep1 ( K1 i c) a Source # to1 :: forall (a :: k0). Rep1 ( K1 i c) a -> K1 i c a Source #
Generic1 (f :+: g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :+: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :+: g) a -> Rep1 (f :+: g) a Source # to1 :: forall (a :: k0). Rep1 (f :+: g) a -> (f :+: g) a Source #
Generic1 (f :*: g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :: g) a -> Rep1 (f :: g) a Source # to1 :: forall (a :: k0). Rep1 (f :: g) a -> (f :*: g) a Source #
Functor f => Generic1 ( Compose f g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Associated Types type Rep1 ( Compose f g) :: k -> Type Source # Methods from1 :: forall (a :: k0). Compose f g a -> Rep1 ( Compose f g) a Source # to1 :: forall (a :: k0). Rep1 ( Compose f g) a -> Compose f g a Source #
Generic1 ( M1 i c f :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( M1 i c f) :: k -> Type Source # Methods from1 :: forall (a :: k0). M1 i c f a -> Rep1 ( M1 i c f) a Source # to1 :: forall (a :: k0). Rep1 ( M1 i c f) a -> M1 i c f a Source #
Functor f => Generic1 (f :.: g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :.: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a Source # to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a Source #
Generic1 ( Sum p q a :: k1 -> Type )
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep1 ( Sum p q a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Sum p q a a0 -> Rep1 ( Sum p q a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Sum p q a) a0 -> Sum p q a a0 Source #
Generic1 ( Product f g a :: k1 -> Type )
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep1 ( Product f g a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Product f g a a0 -> Rep1 ( Product f g a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Product f g a) a0 -> Product f g a a0 Source #
Functor f => Generic1 ( Tannen f p a :: k2 -> Type )
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep1 ( Tannen f p a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Tannen f p a a0 -> Rep1 ( Tannen f p a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Tannen f p a) a0 -> Tannen f p a a0 Source #
Functor (p (f a)) => Generic1 ( Biff p f g a :: k3 -> Type )
Instance details Defined in Data.Bifunctor.Biff Associated Types type Rep1 ( Biff p f g a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Biff p f g a a0 -> Rep1 ( Biff p f g a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Biff p f g a) a0 -> Biff p f g a a0 Source #
Generic1 []	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 [] :: k -> Type Source # Methods from1 :: forall (a :: k). [a] -> Rep1 [] a Source # to1 :: forall (a :: k). Rep1 [] a -> [a] Source #
Generic1 Maybe	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Maybe :: k -> Type Source # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a Source # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a Source #
Generic1 Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Par1 :: k -> Type Source # Methods from1 :: forall (a :: k). Par1 a -> Rep1 Par1 a Source # to1 :: forall (a :: k). Rep1 Par1 a -> Par1 a Source #
Generic1 Solo
Instance details Defined in Data.Tuple.Solo Associated Types type Rep1 Solo :: k -> Type Source # Methods from1 :: forall (a :: k). Solo a -> Rep1 Solo a Source # to1 :: forall (a :: k). Rep1 Solo a -> Solo a Source #
Generic1 Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Associated Types type Rep1 Complex :: k -> Type Source # Methods from1 :: forall (a :: k). Complex a -> Rep1 Complex a Source # to1 :: forall (a :: k). Rep1 Complex a -> Complex a Source #
Generic1 Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Min :: k -> Type Source # Methods from1 :: forall (a :: k). Min a -> Rep1 Min a Source # to1 :: forall (a :: k). Rep1 Min a -> Min a Source #
Generic1 Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Max :: k -> Type Source # Methods from1 :: forall (a :: k). Max a -> Rep1 Max a Source # to1 :: forall (a :: k). Rep1 Max a -> Max a Source #
Generic1 First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 First :: k -> Type Source # Methods from1 :: forall (a :: k). First a -> Rep1 First a Source # to1 :: forall (a :: k). Rep1 First a -> First a Source #
Generic1 Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Last :: k -> Type Source # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a Source # to1 :: forall (a :: k). Rep1 Last a -> Last a Source #
Generic1 WrappedMonoid	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 WrappedMonoid :: k -> Type Source # Methods from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a Source # to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a Source #
Generic1 Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Option :: k -> Type Source # Methods from1 :: forall (a :: k). Option a -> Rep1 Option a Source # to1 :: forall (a :: k). Rep1 Option a -> Option a Source #
Generic1 ZipList	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep1 ZipList :: k -> Type Source # Methods from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a Source # to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a Source #
Generic1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type Source # Methods from1 :: forall (a :: k). Identity a -> Rep1 Identity a Source # to1 :: forall (a :: k). Rep1 Identity a -> Identity a Source #
Generic1 First	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 First :: k -> Type Source # Methods from1 :: forall (a :: k). First a -> Rep1 First a Source # to1 :: forall (a :: k). Rep1 First a -> First a Source #
Generic1 Last	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 Last :: k -> Type Source # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a Source # to1 :: forall (a :: k). Rep1 Last a -> Last a Source #
Generic1 Dual	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Dual :: k -> Type Source # Methods from1 :: forall (a :: k). Dual a -> Rep1 Dual a Source # to1 :: forall (a :: k). Rep1 Dual a -> Dual a Source #
Generic1 Sum	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Sum :: k -> Type Source # Methods from1 :: forall (a :: k). Sum a -> Rep1 Sum a Source # to1 :: forall (a :: k). Rep1 Sum a -> Sum a Source #
Generic1 Product	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Product :: k -> Type Source # Methods from1 :: forall (a :: k). Product a -> Rep1 Product a Source # to1 :: forall (a :: k). Rep1 Product a -> Product a Source #
Generic1 Down	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Down :: k -> Type Source # Methods from1 :: forall (a :: k). Down a -> Rep1 Down a Source # to1 :: forall (a :: k). Rep1 Down a -> Down a Source #
Generic1 NonEmpty	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 NonEmpty :: k -> Type Source # Methods from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a Source # to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a Source #
Generic1 Tree	Since: containers-0.5.8
Instance details Defined in Data.Tree Associated Types type Rep1 Tree :: k -> Type Source # Methods from1 :: forall (a :: k). Tree a -> Rep1 Tree a Source # to1 :: forall (a :: k). Rep1 Tree a -> Tree a Source #
Generic1 FingerTree	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 FingerTree :: k -> Type Source # Methods from1 :: forall (a :: k). FingerTree a -> Rep1 FingerTree a Source # to1 :: forall (a :: k). Rep1 FingerTree a -> FingerTree a Source #
Generic1 Digit	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 Digit :: k -> Type Source # Methods from1 :: forall (a :: k). Digit a -> Rep1 Digit a Source # to1 :: forall (a :: k). Rep1 Digit a -> Digit a Source #
Generic1 Node	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 Node :: k -> Type Source # Methods from1 :: forall (a :: k). Node a -> Rep1 Node a Source # to1 :: forall (a :: k). Rep1 Node a -> Node a Source #
Generic1 Elem	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 Elem :: k -> Type Source # Methods from1 :: forall (a :: k). Elem a -> Rep1 Elem a Source # to1 :: forall (a :: k). Rep1 Elem a -> Elem a Source #
Generic1 ViewL	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 ViewL :: k -> Type Source # Methods from1 :: forall (a :: k). ViewL a -> Rep1 ViewL a Source # to1 :: forall (a :: k). Rep1 ViewL a -> ViewL a Source #
Generic1 ViewR	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 ViewR :: k -> Type Source # Methods from1 :: forall (a :: k). ViewR a -> Rep1 ViewR a Source # to1 :: forall (a :: k). Rep1 ViewR a -> ViewR a Source #
Generic1 Maybe
Instance details Defined in Data.Strict.Maybe Associated Types type Rep1 Maybe :: k -> Type Source # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a Source # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a Source #
Generic1 ( Either a :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( Either a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Either a a0 -> Rep1 ( Either a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Either a) a0 -> Either a a0 Source #
Generic1 ( (,) a :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( (,) a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, a0) -> Rep1 ( (,) a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( (,) a) a0 -> (a, a0) Source #
Generic1 ( Arg a :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 ( Arg a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Arg a a0 -> Rep1 ( Arg a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Arg a) a0 -> Arg a a0 Source #
Generic1 ( WrappedMonad m :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep1 ( WrappedMonad m) :: k -> Type Source # Methods from1 :: forall (a :: k). WrappedMonad m a -> Rep1 ( WrappedMonad m) a Source # to1 :: forall (a :: k). Rep1 ( WrappedMonad m) a -> WrappedMonad m a Source #
Generic1 ( These a :: Type -> Type )
Instance details Defined in Data.These Associated Types type Rep1 ( These a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). These a a0 -> Rep1 ( These a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( These a) a0 -> These a a0 Source #
Generic1 ( Pair a :: Type -> Type )
Instance details Defined in Data.Strict.Tuple Associated Types type Rep1 ( Pair a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Pair a a0 -> Rep1 ( Pair a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Pair a) a0 -> Pair a a0 Source #
Generic1 ( These a :: Type -> Type )
Instance details Defined in Data.Strict.These Associated Types type Rep1 ( These a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). These a a0 -> Rep1 ( These a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( These a) a0 -> These a a0 Source #
Generic1 ( Either a :: Type -> Type )
Instance details Defined in Data.Strict.Either Associated Types type Rep1 ( Either a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Either a a0 -> Rep1 ( Either a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Either a) a0 -> Either a a0 Source #
Generic1 ( (,,) a b :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( (,,) a b) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, a0) -> Rep1 ( (,,) a b) a0 Source # to1 :: forall (a0 :: k). Rep1 ( (,,) a b) a0 -> (a, b, a0) Source #
Generic1 ( WrappedArrow a b :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep1 ( WrappedArrow a b) :: k -> Type Source # Methods from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 ( WrappedArrow a b) a0 Source # to1 :: forall (a0 :: k). Rep1 ( WrappedArrow a b) a0 -> WrappedArrow a b a0 Source #
Generic1 ( Kleisli m a :: Type -> Type )	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Associated Types type Rep1 ( Kleisli m a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 ( Kleisli m a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Kleisli m a) a0 -> Kleisli m a a0 Source #
Generic1 ( Tagged s :: Type -> Type )
Instance details Defined in Data.Tagged Associated Types type Rep1 ( Tagged s) :: k -> Type Source # Methods from1 :: forall (a :: k). Tagged s a -> Rep1 ( Tagged s) a Source # to1 :: forall (a :: k). Rep1 ( Tagged s) a -> Tagged s a Source #
Generic1 ( These1 f g :: Type -> Type )
Instance details Defined in Data.Functor.These Associated Types type Rep1 ( These1 f g) :: k -> Type Source # Methods from1 :: forall (a :: k). These1 f g a -> Rep1 ( These1 f g) a Source # to1 :: forall (a :: k). Rep1 ( These1 f g) a -> These1 f g a Source #
Generic1 ( (,,,) a b c :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( (,,,) a b c) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, a0) -> Rep1 ( (,,,) a b c) a0 Source # to1 :: forall (a0 :: k). Rep1 ( (,,,) a b c) a0 -> (a, b, c, a0) Source #
Generic1 ( (,,,,) a b c d :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( (,,,,) a b c d) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, a0) -> Rep1 ( (,,,,) a b c d) a0 Source # to1 :: forall (a0 :: k). Rep1 ( (,,,,) a b c d) a0 -> (a, b, c, d, a0) Source #
Generic1 ( (,,,,,) a b c d e :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( (,,,,,) a b c d e) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, a0) -> Rep1 ( (,,,,,) a b c d e) a0 Source # to1 :: forall (a0 :: k). Rep1 ( (,,,,,) a b c d e) a0 -> (a, b, c, d, e, a0) Source #
Generic1 ( (,,,,,,) a b c d e f :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( (,,,,,,) a b c d e f) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, f, a0) -> Rep1 ( (,,,,,,) a b c d e f) a0 Source # to1 :: forall (a0 :: k). Rep1 ( (,,,,,,) a b c d e f) a0 -> (a, b, c, d, e, f, a0) Source #

class Datatype (d :: k) where Source #

Class for datatypes that represent datatypes

Minimal complete definition

datatypeName , moduleName , packageName

Methods

datatypeName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> [ Char ] Source #

The name of the datatype (unqualified)

moduleName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> [ Char ] Source #

The fully-qualified name of the module where the type is declared

packageName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> [ Char ] Source #

The package name of the module where the type is declared

Since: base-4.9.0.0

isNewtype :: forall k1 t (f :: k1 -> Type ) (a :: k1). t d f a -> Bool Source #

Marks if the datatype is actually a newtype

Since: base-4.7.0.0

Instances

Instances details

( KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI nt) => Datatype (' MetaData n m p nt :: Meta )

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

datatypeName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> [ Char ] Source #

moduleName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> [ Char ] Source #

packageName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> [ Char ] Source #

isNewtype :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> Bool Source #

class Constructor (c :: k) where Source #

Class for datatypes that represent data constructors

Minimal complete definition

conName

Methods

conName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t c f a -> [ Char ] Source #

The name of the constructor

conFixity :: forall k1 t (f :: k1 -> Type ) (a :: k1). t c f a -> Fixity Source #

The fixity of the constructor

conIsRecord :: forall k1 t (f :: k1 -> Type ) (a :: k1). t c f a -> Bool Source #

Marks if this constructor is a record

Instances

Instances details

( KnownSymbol n, SingI f, SingI r) => Constructor (' MetaCons n f r :: Meta )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods conName :: forall k1 t (f0 :: k1 -> Type ) (a :: k1). t (' MetaCons n f r) f0 a -> [ Char ] Source # conFixity :: forall k1 t (f0 :: k1 -> Type ) (a :: k1). t (' MetaCons n f r) f0 a -> Fixity Source # conIsRecord :: forall k1 t (f0 :: k1 -> Type ) (a :: k1). t (' MetaCons n f r) f0 a -> Bool Source #

class Selector (s :: k) where Source #

Class for datatypes that represent records

Methods

selName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> [ Char ] Source #

The name of the selector

selSourceUnpackedness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> SourceUnpackedness Source #

The selector's unpackedness annotation (if any)

Since: base-4.9.0.0

selSourceStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> SourceStrictness Source #

The selector's strictness annotation (if any)

Since: base-4.9.0.0

selDecidedStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t s f a -> DecidedStrictness Source #

The strictness that the compiler inferred for the selector

Since: base-4.9.0.0

Instances

Instances details

(SingI mn, SingI su, SingI ss, SingI ds) => Selector (' MetaSel mn su ss ds :: Meta )

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

selName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> [ Char ] Source #

selSourceUnpackedness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> SourceUnpackedness Source #

selSourceStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> SourceStrictness Source #

selDecidedStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> DecidedStrictness Source #

class KnownNat (n :: Nat ) Source #

This class gives the integer associated with a type-level natural. There are instances of the class for every concrete literal: 0, 1, 2, etc.

Since: base-4.7.0.0

Minimal complete definition

natSing

class KnownSymbol (n :: Symbol ) Source #

This class gives the string associated with a type-level symbol. There are instances of the class for every concrete literal: "hello", etc.

Since: base-4.7.0.0

Minimal complete definition

symbolSing

class IsLabel (x :: Symbol ) a where Source #

Methods

fromLabel :: a Source #

class Semigroup a where Source #

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

Instances should satisfy the following:

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

Since: base-4.9.0.0

Minimal complete definition

(<>)

Methods

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

An associative operation.

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

sconcat :: NonEmpty a -> a Source #

Reduce a non-empty list with <>

The default definition should be sufficient, but this can be overridden for efficiency.

>>> import Data.List.NonEmpty
>>> sconcat $ "Hello" :| [" ", "Haskell", "!"]
"Hello Haskell!"

stimes :: Integral b => b -> a -> a Source #

Repeat a value n times.

Given that this works on a Semigroup it is allowed to fail if you request 0 or fewer repetitions, and the default definition will do so.

By making this a member of the class, idempotent semigroups and monoids can upgrade this to execute in $\mathcal{O}(1)$ by picking stimes = stimesIdempotent or stimes = stimesIdempotentMonoid respectively.

>>> stimes 4 [1]
[1,1,1,1]

Instances

Instances details

Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering Source # sconcat :: NonEmpty Ordering -> Ordering Source # stimes :: Integral b => b -> Ordering -> Ordering Source #
Semigroup ()	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: () -> () -> () Source # sconcat :: NonEmpty () -> () Source # stimes :: Integral b => b -> () -> () Source #
Semigroup ByteString
Instance details Defined in Data.ByteString.Internal Methods (<>) :: ByteString -> ByteString -> ByteString Source # sconcat :: NonEmpty ByteString -> ByteString Source # stimes :: Integral b => b -> ByteString -> ByteString Source #
Semigroup ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods (<>) :: ByteString -> ByteString -> ByteString Source # sconcat :: NonEmpty ByteString -> ByteString Source # stimes :: Integral b => b -> ByteString -> ByteString Source #
Semigroup Builder
Instance details Defined in Data.Text.Internal.Builder Methods (<>) :: Builder -> Builder -> Builder Source # sconcat :: NonEmpty Builder -> Builder Source # stimes :: Integral b => b -> Builder -> Builder Source #
Semigroup Key
Instance details Defined in Data.Aeson.Key Methods (<>) :: Key -> Key -> Key Source # sconcat :: NonEmpty Key -> Key Source # stimes :: Integral b => b -> Key -> Key Source #
Semigroup More
Instance details Defined in Data.Attoparsec.Internal.Types Methods (<>) :: More -> More -> More Source # sconcat :: NonEmpty More -> More Source # stimes :: Integral b => b -> More -> More Source #
Semigroup Void	Since: base-4.9.0.0
Instance details Defined in Data.Void Methods (<>) :: Void -> Void -> Void Source # sconcat :: NonEmpty Void -> Void Source # stimes :: Integral b => b -> Void -> Void Source #
Semigroup All	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: All -> All -> All Source # sconcat :: NonEmpty All -> All Source # stimes :: Integral b => b -> All -> All Source #
Semigroup Any	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Any -> Any -> Any Source # sconcat :: NonEmpty Any -> Any Source # stimes :: Integral b => b -> Any -> Any Source #
Semigroup ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods (<>) :: ShortByteString -> ShortByteString -> ShortByteString Source # sconcat :: NonEmpty ShortByteString -> ShortByteString Source # stimes :: Integral b => b -> ShortByteString -> ShortByteString Source #
Semigroup JSString
Instance details Defined in Text.JSON.Canonical.Types Methods (<>) :: JSString -> JSString -> JSString Source # sconcat :: NonEmpty JSString -> JSString Source # stimes :: Integral b => b -> JSString -> JSString Source #
Semigroup ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods (<>) :: ByteArray -> ByteArray -> ByteArray Source # sconcat :: NonEmpty ByteArray -> ByteArray Source # stimes :: Integral b => b -> ByteArray -> ByteArray Source #
Semigroup IntSet	Since: containers-0.5.7
Instance details Defined in Data.IntSet.Internal Methods (<>) :: IntSet -> IntSet -> IntSet Source # sconcat :: NonEmpty IntSet -> IntSet Source # stimes :: Integral b => b -> IntSet -> IntSet Source #
Semigroup Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods (<>) :: Doc -> Doc -> Doc Source # sconcat :: NonEmpty Doc -> Doc Source # stimes :: Integral b => b -> Doc -> Doc Source #
Semigroup ShortText
Instance details Defined in Data.Text.Short.Internal Methods (<>) :: ShortText -> ShortText -> ShortText Source # sconcat :: NonEmpty ShortText -> ShortText Source # stimes :: Integral b => b -> ShortText -> ShortText Source #
Semigroup [a]	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: [a] -> [a] -> [a] Source # sconcat :: NonEmpty [a] -> [a] Source # stimes :: Integral b => b -> [a] -> [a] Source #
Semigroup a => Semigroup ( Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a Source # sconcat :: NonEmpty ( Maybe a) -> Maybe a Source # stimes :: Integral b => b -> Maybe a -> Maybe a Source #
Semigroup a => Semigroup ( IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a Source # sconcat :: NonEmpty ( IO a) -> IO a Source # stimes :: Integral b => b -> IO a -> IO a Source #
Semigroup p => Semigroup ( Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Par1 p -> Par1 p -> Par1 p Source # sconcat :: NonEmpty ( Par1 p) -> Par1 p Source # stimes :: Integral b => b -> Par1 p -> Par1 p Source #
Semigroup a => Semigroup ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods (<>) :: Solo a -> Solo a -> Solo a Source # sconcat :: NonEmpty ( Solo a) -> Solo a Source # stimes :: Integral b => b -> Solo a -> Solo a Source #
Semigroup ( IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: IResult a -> IResult a -> IResult a Source # sconcat :: NonEmpty ( IResult a) -> IResult a Source # stimes :: Integral b => b -> IResult a -> IResult a Source #
Semigroup ( Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: Result a -> Result a -> Result a Source # sconcat :: NonEmpty ( Result a) -> Result a Source # stimes :: Integral b => b -> Result a -> Result a Source #
Semigroup ( Parser a)
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: Parser a -> Parser a -> Parser a Source # sconcat :: NonEmpty ( Parser a) -> Parser a Source # stimes :: Integral b => b -> Parser a -> Parser a Source #
Semigroup ( KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods (<>) :: KeyMap v -> KeyMap v -> KeyMap v Source # sconcat :: NonEmpty ( KeyMap v) -> KeyMap v Source # stimes :: Integral b => b -> KeyMap v -> KeyMap v Source #
Semigroup a => Semigroup ( Concurrently a)	Only defined by `async` for `base >= 4.9` Since: async-2.1.0
Instance details Defined in Control.Concurrent.Async Methods (<>) :: Concurrently a -> Concurrently a -> Concurrently a Source # sconcat :: NonEmpty ( Concurrently a) -> Concurrently a Source # stimes :: Integral b => b -> Concurrently a -> Concurrently a Source #
Ord a => Semigroup ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Min a -> Min a -> Min a Source # sconcat :: NonEmpty ( Min a) -> Min a Source # stimes :: Integral b => b -> Min a -> Min a Source #
Ord a => Semigroup ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Max a -> Max a -> Max a Source # sconcat :: NonEmpty ( Max a) -> Max a Source # stimes :: Integral b => b -> Max a -> Max a Source #
Semigroup ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: First a -> First a -> First a Source # sconcat :: NonEmpty ( First a) -> First a Source # stimes :: Integral b => b -> First a -> First a Source #
Semigroup ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Last a -> Last a -> Last a Source # sconcat :: NonEmpty ( Last a) -> Last a Source # stimes :: Integral b => b -> Last a -> Last a Source #
Monoid m => Semigroup ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # sconcat :: NonEmpty ( WrappedMonoid m) -> WrappedMonoid m Source # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m Source #
Semigroup a => Semigroup ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Option a -> Option a -> Option a Source # sconcat :: NonEmpty ( Option a) -> Option a Source # stimes :: Integral b => b -> Option a -> Option a Source #
Semigroup a => Semigroup ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a Source # sconcat :: NonEmpty ( Identity a) -> Identity a Source # stimes :: Integral b => b -> Identity a -> Identity a Source #
Semigroup ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: First a -> First a -> First a Source # sconcat :: NonEmpty ( First a) -> First a Source # stimes :: Integral b => b -> First a -> First a Source #
Semigroup ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Last a -> Last a -> Last a Source # sconcat :: NonEmpty ( Last a) -> Last a Source # stimes :: Integral b => b -> Last a -> Last a Source #
Semigroup a => Semigroup ( Dual a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Dual a -> Dual a -> Dual a Source # sconcat :: NonEmpty ( Dual a) -> Dual a Source # stimes :: Integral b => b -> Dual a -> Dual a Source #
Semigroup ( Endo a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Endo a -> Endo a -> Endo a Source # sconcat :: NonEmpty ( Endo a) -> Endo a Source # stimes :: Integral b => b -> Endo a -> Endo a Source #
Num a => Semigroup ( Sum a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Sum a -> Sum a -> Sum a Source # sconcat :: NonEmpty ( Sum a) -> Sum a Source # stimes :: Integral b => b -> Sum a -> Sum a Source #
Num a => Semigroup ( Product a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Product a -> Product a -> Product a Source # sconcat :: NonEmpty ( Product a) -> Product a Source # stimes :: Integral b => b -> Product a -> Product a Source #
Semigroup a => Semigroup ( Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (<>) :: Down a -> Down a -> Down a Source # sconcat :: NonEmpty ( Down a) -> Down a Source # stimes :: Integral b => b -> Down a -> Down a Source #
Semigroup ( NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a Source # sconcat :: NonEmpty ( NonEmpty a) -> NonEmpty a Source # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a Source #
Semigroup ( IntMap a)	Since: containers-0.5.7
Instance details Defined in Data.IntMap.Internal Methods (<>) :: IntMap a -> IntMap a -> IntMap a Source # sconcat :: NonEmpty ( IntMap a) -> IntMap a Source # stimes :: Integral b => b -> IntMap a -> IntMap a Source #
Semigroup ( Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a Source # sconcat :: NonEmpty ( Seq a) -> Seq a Source # stimes :: Integral b => b -> Seq a -> Seq a Source #
Ord a => Semigroup ( Set a)	Since: containers-0.5.7
Instance details Defined in Data.Set.Internal Methods (<>) :: Set a -> Set a -> Set a Source # sconcat :: NonEmpty ( Set a) -> Set a Source # stimes :: Integral b => b -> Set a -> Set a Source #
Semigroup ( DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods (<>) :: DNonEmpty a -> DNonEmpty a -> DNonEmpty a Source # sconcat :: NonEmpty ( DNonEmpty a) -> DNonEmpty a Source # stimes :: Integral b => b -> DNonEmpty a -> DNonEmpty a Source #
Semigroup ( DList a)
Instance details Defined in Data.DList.Internal Methods (<>) :: DList a -> DList a -> DList a Source # sconcat :: NonEmpty ( DList a) -> DList a Source # stimes :: Integral b => b -> DList a -> DList a Source #
Semigroup ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (<>) :: Doc a -> Doc a -> Doc a Source # sconcat :: NonEmpty ( Doc a) -> Doc a Source # stimes :: Integral b => b -> Doc a -> Doc a Source #
Semigroup ( PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods (<>) :: PrimArray a -> PrimArray a -> PrimArray a Source # sconcat :: NonEmpty ( PrimArray a) -> PrimArray a Source # stimes :: Integral b => b -> PrimArray a -> PrimArray a Source #
Semigroup ( SmallArray a)	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.SmallArray Methods (<>) :: SmallArray a -> SmallArray a -> SmallArray a Source # sconcat :: NonEmpty ( SmallArray a) -> SmallArray a Source # stimes :: Integral b => b -> SmallArray a -> SmallArray a Source #
Semigroup ( Array a)	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.Array Methods (<>) :: Array a -> Array a -> Array a Source # sconcat :: NonEmpty ( Array a) -> Array a Source # stimes :: Integral b => b -> Array a -> Array a Source #
Semigroup a => Semigroup ( Maybe a)
Instance details Defined in Data.Strict.Maybe Methods (<>) :: Maybe a -> Maybe a -> Maybe a Source # sconcat :: NonEmpty ( Maybe a) -> Maybe a Source # stimes :: Integral b => b -> Maybe a -> Maybe a Source #
( Hashable a, Eq a) => Semigroup ( HashSet a)	`<>` = `union` $O(n+m)$ To obtain good performance, the smaller set must be presented as the first argument. Examples Expand `>>>` `fromList [1,2] <> fromList [2,3]`fromList [1,2,3]
Instance details Defined in Data.HashSet.Internal Methods (<>) :: HashSet a -> HashSet a -> HashSet a Source # sconcat :: NonEmpty ( HashSet a) -> HashSet a Source # stimes :: Integral b => b -> HashSet a -> HashSet a Source #
Storable a => Semigroup ( Vector a)
Instance details Defined in Data.Vector.Storable Methods (<>) :: Vector a -> Vector a -> Vector a Source # sconcat :: NonEmpty ( Vector a) -> Vector a Source # stimes :: Integral b => b -> Vector a -> Vector a Source #
Prim a => Semigroup ( Vector a)
Instance details Defined in Data.Vector.Primitive Methods (<>) :: Vector a -> Vector a -> Vector a Source # sconcat :: NonEmpty ( Vector a) -> Vector a Source # stimes :: Integral b => b -> Vector a -> Vector a Source #
Semigroup ( Vector a)
Instance details Defined in Data.Vector Methods (<>) :: Vector a -> Vector a -> Vector a Source # sconcat :: NonEmpty ( Vector a) -> Vector a Source # stimes :: Integral b => b -> Vector a -> Vector a Source #
Semigroup (MergeSet a)
Instance details Defined in Data.Set.Internal Methods (<>) :: MergeSet a -> MergeSet a -> MergeSet a Source # sconcat :: NonEmpty (MergeSet a) -> MergeSet a Source # stimes :: Integral b => b -> MergeSet a -> MergeSet a Source #
Semigroup b => Semigroup (a -> b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a -> b) -> (a -> b) -> a -> b Source # sconcat :: NonEmpty (a -> b) -> a -> b Source # stimes :: Integral b0 => b0 -> (a -> b) -> a -> b Source #
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 Source # sconcat :: NonEmpty ( Either a b) -> Either a b Source # stimes :: Integral b0 => b0 -> Either a b -> Either a b Source #
Semigroup ( V1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: V1 p -> V1 p -> V1 p Source # sconcat :: NonEmpty ( V1 p) -> V1 p Source # stimes :: Integral b => b -> V1 p -> V1 p Source #
Semigroup ( U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: U1 p -> U1 p -> U1 p Source # sconcat :: NonEmpty ( U1 p) -> U1 p Source # stimes :: Integral b => b -> U1 p -> U1 p Source #
( 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) Source # sconcat :: NonEmpty (a, b) -> (a, b) Source # stimes :: Integral b0 => b0 -> (a, b) -> (a, b) Source #
Ord k => Semigroup ( Map k v)
Instance details Defined in Data.Map.Internal Methods (<>) :: Map k v -> Map k v -> Map k v Source # sconcat :: NonEmpty ( Map k v) -> Map k v Source # stimes :: Integral b => b -> Map k v -> Map k v Source #
( Eq k, Hashable k) => Semigroup ( HashMap k v)	`<>` = `union` If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples Expand `>>>` `fromList [(1,'a'),(2,'b')] <> fromList [(2,'c'),(3,'d')]`fromList [(1,'a'),(2,'b'),(3,'d')]
Instance details Defined in Data.HashMap.Internal Methods (<>) :: HashMap k v -> HashMap k v -> HashMap k v Source # sconcat :: NonEmpty ( HashMap k v) -> HashMap k v Source # stimes :: Integral b => b -> HashMap k v -> HashMap k v Source #
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 Source # sconcat :: NonEmpty ( ST s a) -> ST s a Source # stimes :: Integral b => b -> ST s a -> ST s a Source #
Semigroup ( Parser i a)
Instance details Defined in Data.Attoparsec.Internal.Types Methods (<>) :: Parser i a -> Parser i a -> Parser i a Source # sconcat :: NonEmpty ( Parser i a) -> Parser i a Source # stimes :: Integral b => b -> Parser i a -> Parser i a Source #
Semigroup ( Proxy s)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods (<>) :: Proxy s -> Proxy s -> Proxy s Source # sconcat :: NonEmpty ( Proxy s) -> Proxy s Source # stimes :: Integral b => b -> Proxy s -> Proxy s Source #
Semigroup ( Format r (a -> r))
Instance details Defined in Formatting.Internal Methods (<>) :: Format r (a -> r) -> Format r (a -> r) -> Format r (a -> r) Source # sconcat :: NonEmpty ( Format r (a -> r)) -> Format r (a -> r) Source # stimes :: Integral b => b -> Format r (a -> r) -> Format r (a -> r) Source #
( Semigroup a, Semigroup b) => Semigroup ( These a b)
Instance details Defined in Data.These Methods (<>) :: These a b -> These a b -> These a b Source # sconcat :: NonEmpty ( These a b) -> These a b Source # stimes :: Integral b0 => b0 -> These a b -> These a b Source #
( Semigroup a, Semigroup b) => Semigroup ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods (<>) :: Pair a b -> Pair a b -> Pair a b Source # sconcat :: NonEmpty ( Pair a b) -> Pair a b Source # stimes :: Integral b0 => b0 -> Pair a b -> Pair a b Source #
( Semigroup a, Semigroup b) => Semigroup ( These a b)
Instance details Defined in Data.Strict.These Methods (<>) :: These a b -> These a b -> These a b Source # sconcat :: NonEmpty ( These a b) -> These a b Source # stimes :: Integral b0 => b0 -> These a b -> These a b Source #
Semigroup ( Either a b)
Instance details Defined in Data.Strict.Either Methods (<>) :: Either a b -> Either a b -> Either a b Source # sconcat :: NonEmpty ( Either a b) -> Either a b Source # stimes :: Integral b0 => b0 -> Either a b -> Either a b Source #
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 Source # sconcat :: NonEmpty ( Rec1 f p) -> Rec1 f p Source # stimes :: Integral b => b -> Rec1 f p -> Rec1 f p Source #
( 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) Source # sconcat :: NonEmpty (a, b, c) -> (a, b, c) Source # stimes :: Integral b0 => b0 -> (a, b, c) -> (a, b, c) Source #
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 Source # sconcat :: NonEmpty ( Const a b) -> Const a b Source # stimes :: Integral b0 => b0 -> Const a b -> Const a b Source #
( Applicative f, Semigroup a) => Semigroup ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Ap f a -> Ap f a -> Ap f a Source # sconcat :: NonEmpty ( Ap f a) -> Ap f a Source # stimes :: Integral b => b -> Ap f a -> Ap f a Source #
Alternative f => Semigroup ( Alt f a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Alt f a -> Alt f a -> Alt f a Source # sconcat :: NonEmpty ( Alt f a) -> Alt f a Source # stimes :: Integral b => b -> Alt f a -> Alt f a Source #
Semigroup a => Semigroup ( Tagged s a)
Instance details Defined in Data.Tagged Methods (<>) :: Tagged s a -> Tagged s a -> Tagged s a Source # sconcat :: NonEmpty ( Tagged s a) -> Tagged s a Source # stimes :: Integral b => b -> Tagged s a -> Tagged s a Source #
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 Source # sconcat :: NonEmpty ( K1 i c p) -> K1 i c p Source # stimes :: Integral b => b -> K1 i c p -> K1 i c p Source #
( 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 Source # sconcat :: NonEmpty ((f :: g) p) -> (f :: g) p Source # stimes :: Integral b => b -> (f :: g) p -> (f :*: g) p Source #
( 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) Source # sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) Source # stimes :: Integral b0 => b0 -> (a, b, c, d) -> (a, b, c, d) Source #
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 Source # sconcat :: NonEmpty ( M1 i c f p) -> M1 i c f p Source # stimes :: Integral b => b -> M1 i c f p -> M1 i c f p Source #
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 Source # sconcat :: NonEmpty ((f :.: g) p) -> (f :.: g) p Source # stimes :: Integral b => b -> (f :.: g) p -> (f :.: g) p Source #
( 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) Source # sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) Source # stimes :: Integral b0 => b0 -> (a, b, c, d, e) -> (a, b, c, d, e) Source #

class Semigroup a => Monoid a where Source #

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

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 newtype s 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

Methods

mempty :: a Source #

Identity of mappend

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

mappend :: a -> a -> a Source #

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

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 Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering Source # mappend :: Ordering -> Ordering -> Ordering Source # mconcat :: [ Ordering ] -> Ordering Source #
Monoid ()	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: () Source # mappend :: () -> () -> () Source # mconcat :: [()] -> () Source #
Monoid ByteString
Instance details Defined in Data.ByteString.Internal Methods mempty :: ByteString Source # mappend :: ByteString -> ByteString -> ByteString Source # mconcat :: [ ByteString ] -> ByteString Source #
Monoid ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods mempty :: ByteString Source # mappend :: ByteString -> ByteString -> ByteString Source # mconcat :: [ ByteString ] -> ByteString Source #
Monoid Builder
Instance details Defined in Data.Text.Internal.Builder Methods mempty :: Builder Source # mappend :: Builder -> Builder -> Builder Source # mconcat :: [ Builder ] -> Builder Source #
Monoid Key
Instance details Defined in Data.Aeson.Key Methods mempty :: Key Source # mappend :: Key -> Key -> Key Source # mconcat :: [ Key ] -> Key Source #
Monoid More
Instance details Defined in Data.Attoparsec.Internal.Types Methods mempty :: More Source # mappend :: More -> More -> More Source # mconcat :: [ More ] -> More Source #
Monoid All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: All Source # mappend :: All -> All -> All Source # mconcat :: [ All ] -> All Source #
Monoid Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Any Source # mappend :: Any -> Any -> Any Source # mconcat :: [ Any ] -> Any Source #
Monoid ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods mempty :: ShortByteString Source # mappend :: ShortByteString -> ShortByteString -> ShortByteString Source # mconcat :: [ ShortByteString ] -> ShortByteString Source #
Monoid JSString
Instance details Defined in Text.JSON.Canonical.Types Methods mempty :: JSString Source # mappend :: JSString -> JSString -> JSString Source # mconcat :: [ JSString ] -> JSString Source #
Monoid ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods mempty :: ByteArray Source # mappend :: ByteArray -> ByteArray -> ByteArray Source # mconcat :: [ ByteArray ] -> ByteArray Source #
Monoid IntSet
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet Source # mappend :: IntSet -> IntSet -> IntSet Source # mconcat :: [ IntSet ] -> IntSet Source #
Monoid Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods mempty :: Doc Source # mappend :: Doc -> Doc -> Doc Source # mconcat :: [ Doc ] -> Doc Source #
Monoid ShortText
Instance details Defined in Data.Text.Short.Internal Methods mempty :: ShortText Source # mappend :: ShortText -> ShortText -> ShortText Source # mconcat :: [ ShortText ] -> ShortText Source #
Monoid [a]	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: [a] Source # mappend :: [a] -> [a] -> [a] Source # mconcat :: [[a]] -> [a] Source #
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 Source # mappend :: Maybe a -> Maybe a -> Maybe a Source # mconcat :: [ Maybe a] -> Maybe a Source #
Monoid a => Monoid ( IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a Source # mappend :: IO a -> IO a -> IO a Source # mconcat :: [ IO a] -> IO a Source #
Monoid p => Monoid ( Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Par1 p Source # mappend :: Par1 p -> Par1 p -> Par1 p Source # mconcat :: [ Par1 p] -> Par1 p Source #
Monoid a => Monoid ( Solo a)
Instance details Defined in Data.Tuple.Solo Methods mempty :: Solo a Source # mappend :: Solo a -> Solo a -> Solo a Source # mconcat :: [ Solo a] -> Solo a Source #
Monoid ( IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: IResult a Source # mappend :: IResult a -> IResult a -> IResult a Source # mconcat :: [ IResult a] -> IResult a Source #
Monoid ( Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: Result a Source # mappend :: Result a -> Result a -> Result a Source # mconcat :: [ Result a] -> Result a Source #
Monoid ( Parser a)
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: Parser a Source # mappend :: Parser a -> Parser a -> Parser a Source # mconcat :: [ Parser a] -> Parser a Source #
Monoid ( KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods mempty :: KeyMap v Source # mappend :: KeyMap v -> KeyMap v -> KeyMap v Source # mconcat :: [ KeyMap v] -> KeyMap v Source #
( Semigroup a, Monoid a) => Monoid ( Concurrently a)	Since: async-2.1.0
Instance details Defined in Control.Concurrent.Async Methods mempty :: Concurrently a Source # mappend :: Concurrently a -> Concurrently a -> Concurrently a Source # mconcat :: [ Concurrently a] -> Concurrently a Source #
( Ord a, Bounded a) => Monoid ( Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Min a Source # mappend :: Min a -> Min a -> Min a Source # mconcat :: [ Min a] -> Min a Source #
( Ord a, Bounded a) => Monoid ( Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Max a Source # mappend :: Max a -> Max a -> Max a Source # mconcat :: [ Max a] -> Max a Source #
Monoid m => Monoid ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: WrappedMonoid m Source # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # mconcat :: [ WrappedMonoid m] -> WrappedMonoid m Source #
Semigroup a => Monoid ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Option a Source # mappend :: Option a -> Option a -> Option a Source # mconcat :: [ Option a] -> Option a Source #
Monoid a => Monoid ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a Source # mappend :: Identity a -> Identity a -> Identity a Source # mconcat :: [ Identity a] -> Identity a Source #
Monoid ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: First a Source # mappend :: First a -> First a -> First a Source # mconcat :: [ First a] -> First a Source #
Monoid ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: Last a Source # mappend :: Last a -> Last a -> Last a Source # mconcat :: [ Last a] -> Last a Source #
Monoid a => Monoid ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Dual a Source # mappend :: Dual a -> Dual a -> Dual a Source # mconcat :: [ Dual a] -> Dual a Source #
Monoid ( Endo a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Endo a Source # mappend :: Endo a -> Endo a -> Endo a Source # mconcat :: [ Endo a] -> Endo a Source #
Num a => Monoid ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Sum a Source # mappend :: Sum a -> Sum a -> Sum a Source # mconcat :: [ Sum a] -> Sum a Source #
Num a => Monoid ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Product a Source # mappend :: Product a -> Product a -> Product a Source # mconcat :: [ Product a] -> Product a Source #
Monoid a => Monoid ( Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a Source # mappend :: Down a -> Down a -> Down a Source # mconcat :: [ Down a] -> Down a Source #
Monoid ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods mempty :: IntMap a Source # mappend :: IntMap a -> IntMap a -> IntMap a Source # mconcat :: [ IntMap a] -> IntMap a Source #
Monoid ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a Source # mappend :: Seq a -> Seq a -> Seq a Source # mconcat :: [ Seq a] -> Seq a Source #
Ord a => Monoid ( Set a)
Instance details Defined in Data.Set.Internal Methods mempty :: Set a Source # mappend :: Set a -> Set a -> Set a Source # mconcat :: [ Set a] -> Set a Source #
Monoid ( DList a)
Instance details Defined in Data.DList.Internal Methods mempty :: DList a Source # mappend :: DList a -> DList a -> DList a Source # mconcat :: [ DList a] -> DList a Source #
Monoid ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods mempty :: Doc a Source # mappend :: Doc a -> Doc a -> Doc a Source # mconcat :: [ Doc a] -> Doc a Source #
Monoid ( PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods mempty :: PrimArray a Source # mappend :: PrimArray a -> PrimArray a -> PrimArray a Source # mconcat :: [ PrimArray a] -> PrimArray a Source #
Monoid ( SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods mempty :: SmallArray a Source # mappend :: SmallArray a -> SmallArray a -> SmallArray a Source # mconcat :: [ SmallArray a] -> SmallArray a Source #
Monoid ( Array a)
Instance details Defined in Data.Primitive.Array Methods mempty :: Array a Source # mappend :: Array a -> Array a -> Array a Source # mconcat :: [ Array a] -> Array a Source #
Semigroup a => Monoid ( Maybe a)
Instance details Defined in Data.Strict.Maybe Methods mempty :: Maybe a Source # mappend :: Maybe a -> Maybe a -> Maybe a Source # mconcat :: [ Maybe a] -> Maybe a Source #
( Hashable a, Eq a) => Monoid ( HashSet a)	`mempty` = `empty` `mappend` = `union` $O(n+m)$ To obtain good performance, the smaller set must be presented as the first argument. Examples Expand `>>>` `mappend (fromList [1,2]) (fromList [2,3])`fromList [1,2,3]
Instance details Defined in Data.HashSet.Internal Methods mempty :: HashSet a Source # mappend :: HashSet a -> HashSet a -> HashSet a Source # mconcat :: [ HashSet a] -> HashSet a Source #
Storable a => Monoid ( Vector a)
Instance details Defined in Data.Vector.Storable Methods mempty :: Vector a Source # mappend :: Vector a -> Vector a -> Vector a Source # mconcat :: [ Vector a] -> Vector a Source #
Prim a => Monoid ( Vector a)
Instance details Defined in Data.Vector.Primitive Methods mempty :: Vector a Source # mappend :: Vector a -> Vector a -> Vector a Source # mconcat :: [ Vector a] -> Vector a Source #
Monoid ( Vector a)
Instance details Defined in Data.Vector Methods mempty :: Vector a Source # mappend :: Vector a -> Vector a -> Vector a Source # mconcat :: [ Vector a] -> Vector a Source #
Monoid (MergeSet a)
Instance details Defined in Data.Set.Internal Methods mempty :: MergeSet a Source # mappend :: MergeSet a -> MergeSet a -> MergeSet a Source # mconcat :: [MergeSet a] -> MergeSet a Source #
Monoid b => Monoid (a -> b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: a -> b Source # mappend :: (a -> b) -> (a -> b) -> a -> b Source # mconcat :: [a -> b] -> a -> b Source #
Monoid ( U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: U1 p Source # mappend :: U1 p -> U1 p -> U1 p Source # mconcat :: [ U1 p] -> U1 p Source #
( Monoid a, Monoid b) => Monoid (a, b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b) Source # mappend :: (a, b) -> (a, b) -> (a, b) Source # mconcat :: [(a, b)] -> (a, b) Source #
Ord k => Monoid ( Map k v)
Instance details Defined in Data.Map.Internal Methods mempty :: Map k v Source # mappend :: Map k v -> Map k v -> Map k v Source # mconcat :: [ Map k v] -> Map k v Source #
( Eq k, Hashable k) => Monoid ( HashMap k v)	`mempty` = `empty` `mappend` = `union` If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples Expand `>>>` `mappend (fromList [(1,'a'),(2,'b')]) (fromList [(2,'c'),(3,'d')])`fromList [(1,'a'),(2,'b'),(3,'d')]
Instance details Defined in Data.HashMap.Internal Methods mempty :: HashMap k v Source # mappend :: HashMap k v -> HashMap k v -> HashMap k v Source # mconcat :: [ HashMap k v] -> HashMap k v Source #
Monoid a => Monoid ( ST s a)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods mempty :: ST s a Source # mappend :: ST s a -> ST s a -> ST s a Source # mconcat :: [ ST s a] -> ST s a Source #
Monoid ( Parser i a)
Instance details Defined in Data.Attoparsec.Internal.Types Methods mempty :: Parser i a Source # mappend :: Parser i a -> Parser i a -> Parser i a Source # mconcat :: [ Parser i a] -> Parser i a Source #
Monoid ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s Source # mappend :: Proxy s -> Proxy s -> Proxy s Source # mconcat :: [ Proxy s] -> Proxy s Source #
Monoid ( Format r (a -> r))	Useful instance for applying two formatters to the same input argument. For example: `format (year <> "/" % month) now` will yield `"2015/01"` .
Instance details Defined in Formatting.Internal Methods mempty :: Format r (a -> r) Source # mappend :: Format r (a -> r) -> Format r (a -> r) -> Format r (a -> r) Source # mconcat :: [ Format r (a -> r)] -> Format r (a -> r) Source #
( Monoid a, Monoid b) => Monoid ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods mempty :: Pair a b Source # mappend :: Pair a b -> Pair a b -> Pair a b Source # mconcat :: [ Pair a b] -> Pair a b Source #
Monoid (f p) => Monoid ( Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Rec1 f p Source # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p Source # mconcat :: [ Rec1 f p] -> Rec1 f p Source #
( 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) Source # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) Source # mconcat :: [(a, b, c)] -> (a, b, c) Source #
Monoid a => Monoid ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b Source # mappend :: Const a b -> Const a b -> Const a b Source # mconcat :: [ Const a b] -> Const a b Source #
( Applicative f, Monoid a) => Monoid ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mempty :: Ap f a Source # mappend :: Ap f a -> Ap f a -> Ap f a Source # mconcat :: [ Ap f a] -> Ap f a Source #
Alternative f => Monoid ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Alt f a Source # mappend :: Alt f a -> Alt f a -> Alt f a Source # mconcat :: [ Alt f a] -> Alt f a Source #
( Semigroup a, Monoid a) => Monoid ( Tagged s a)
Instance details Defined in Data.Tagged Methods mempty :: Tagged s a Source # mappend :: Tagged s a -> Tagged s a -> Tagged s a Source # mconcat :: [ Tagged s a] -> Tagged s a Source #
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 Source # mappend :: K1 i c p -> K1 i c p -> K1 i c p Source # mconcat :: [ K1 i c p] -> K1 i c p Source #
( 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 Source # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # mconcat :: [(f :: g) p] -> (f :: g) p Source #
( 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) Source # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source # mconcat :: [(a, b, c, d)] -> (a, b, c, d) Source #
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 Source # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # mconcat :: [ M1 i c f p] -> M1 i c f p Source #
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 Source # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # mconcat :: [(f :.: g) p] -> (f :.: g) p Source #
( 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) Source # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) Source #

class HasField (x :: k) r a | x r -> a where Source #

Constraint representing the fact that the field x belongs to the record type r and has field type a . This will be solved automatically, but manual instances may be provided as well.

Methods

getField :: r -> a Source #

Selector function to extract the field from the record.

data Bool Source #

Constructors

False
True

Instances

Instances details

Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool Source # maxBound :: Bool Source #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool Source # pred :: Bool -> Bool Source # toEnum :: Int -> Bool Source # fromEnum :: Bool -> Int Source # enumFrom :: Bool -> [ Bool ] Source # enumFromThen :: Bool -> Bool -> [ Bool ] Source # enumFromTo :: Bool -> Bool -> [ Bool ] Source # enumFromThenTo :: Bool -> Bool -> Bool -> [ Bool ] Source #
Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool Source # (/=) :: Bool -> Bool -> Bool Source #
Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering Source # (<) :: Bool -> Bool -> Bool Source # (<=) :: Bool -> Bool -> Bool Source # (>) :: Bool -> Bool -> Bool Source # (>=) :: Bool -> Bool -> Bool Source # max :: Bool -> Bool -> Bool Source # min :: Bool -> Bool -> Bool Source #
Read Bool	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Bool Source # readList :: ReadS [ Bool ] Source # readPrec :: ReadPrec Bool Source # readListPrec :: ReadPrec [ Bool ] Source #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS Source # show :: Bool -> String Source # showList :: [ Bool ] -> ShowS Source #
Ix Bool	Since: base-2.1
Instance details Defined in GHC.Ix Methods range :: ( Bool , Bool ) -> [ Bool ] Source # index :: ( Bool , Bool ) -> Bool -> Int Source # unsafeIndex :: ( Bool , Bool ) -> Bool -> Int Source # inRange :: ( Bool , Bool ) -> Bool -> Bool Source # rangeSize :: ( Bool , Bool ) -> Int Source # unsafeRangeSize :: ( Bool , Bool ) -> Int Source #
Generic Bool	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type Source # Methods from :: Bool -> Rep Bool x Source # to :: Rep Bool x -> Bool Source #
Hashable Bool
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Bool -> Int Source # hash :: Bool -> Int Source #
Storable Bool	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Bool -> Int Source # alignment :: Bool -> Int Source # peekElemOff :: Ptr Bool -> Int -> IO Bool Source # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Bool Source # pokeByteOff :: Ptr b -> Int -> Bool -> IO () Source # peek :: Ptr Bool -> IO Bool Source # poke :: Ptr Bool -> Bool -> IO () Source #
Bits Bool	Interpret `Bool` as 1-bit bit-field Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods (.&.) :: Bool -> Bool -> Bool Source # (.\|.) :: Bool -> Bool -> Bool Source # xor :: Bool -> Bool -> Bool Source # complement :: Bool -> Bool Source # shift :: Bool -> Int -> Bool Source # rotate :: Bool -> Int -> Bool Source # zeroBits :: Bool Source # bit :: Int -> Bool Source # setBit :: Bool -> Int -> Bool Source # clearBit :: Bool -> Int -> Bool Source # complementBit :: Bool -> Int -> Bool Source # testBit :: Bool -> Int -> Bool Source # bitSizeMaybe :: Bool -> Maybe Int Source # bitSize :: Bool -> Int Source # isSigned :: Bool -> Bool Source # shiftL :: Bool -> Int -> Bool Source # unsafeShiftL :: Bool -> Int -> Bool Source # shiftR :: Bool -> Int -> Bool Source # unsafeShiftR :: Bool -> Int -> Bool Source # rotateL :: Bool -> Int -> Bool Source # rotateR :: Bool -> Int -> Bool Source # popCount :: Bool -> Int Source #
FiniteBits Bool	Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Bool -> Int Source # countLeadingZeros :: Bool -> Int Source # countTrailingZeros :: Bool -> Int Source #
NFData Bool
Instance details Defined in Control.DeepSeq Methods rnf :: Bool -> () Source #
Buildable Bool
Instance details Defined in Formatting.Buildable Methods build :: Bool -> Builder Source #
Uniform Bool
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Bool Source #
UniformRange Bool
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Bool , Bool ) -> g -> m Bool Source #
Unbox Bool
Instance details Defined in Data.Vector.Unboxed.Base
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
HeapWords Bool Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Bool -> Int Source #
Lift Bool
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Bool -> Q Exp Source # liftTyped :: Bool -> Q ( TExp Bool ) Source #
IArray UArray Bool
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Bool -> (i, i) Source # numElements :: Ix i => UArray i Bool -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Bool )] -> UArray i Bool unsafeAt :: Ix i => UArray i Bool -> Int -> Bool unsafeReplace :: Ix i => UArray i Bool -> [( Int , Bool )] -> UArray i Bool unsafeAccum :: Ix i => ( Bool -> e' -> Bool ) -> UArray i Bool -> [( Int , e')] -> UArray i Bool unsafeAccumArray :: Ix i => ( Bool -> e' -> Bool ) -> Bool -> (i, i) -> [( Int , e')] -> UArray i Bool
Vector Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Bool -> m ( Vector Bool ) Source # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m ( Mutable Vector ( PrimState m) Bool ) Source # basicLength :: Vector Bool -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool Source # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Bool -> Vector Bool -> m () Source # elemseq :: Vector Bool -> Bool -> b -> b Source #
MVector MVector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool Source # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Bool ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Bool -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m ( MVector ( PrimState m) Bool ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Bool -> Int -> m Bool Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Bool -> Int -> Bool -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Bool -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Bool -> Bool -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Bool -> MVector ( PrimState m) Bool -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Bool -> MVector ( PrimState m) Bool -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Bool -> Int -> m ( MVector ( PrimState m) Bool ) Source #
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
MArray ( STUArray s) Bool ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Bool -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Bool -> ST s Int newArray :: Ix i => (i, i) -> Bool -> ST s ( STUArray s i Bool ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Bool ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Bool ) unsafeRead :: Ix i => STUArray s i Bool -> Int -> ST s Bool unsafeWrite :: Ix i => STUArray s i Bool -> Int -> Bool -> ST s ()
type Rep Bool
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 ))
newtype Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Bool = V_Bool ( Vector Word8 )
type DemoteRep Bool
Instance details Defined in GHC.Generics type DemoteRep Bool = Bool
data Sing (a :: Bool )
Instance details Defined in GHC.Generics data Sing (a :: Bool ) where STrue :: Sing ' True SFalse :: Sing ' False
newtype MVector s Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Bool = MV_Bool ( MVector s Word8 )

data Char Source #

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

Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char Source # maxBound :: Char Source #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char Source # pred :: Char -> Char Source # toEnum :: Int -> Char Source # fromEnum :: Char -> Int Source # enumFrom :: Char -> [ Char ] Source # enumFromThen :: Char -> Char -> [ Char ] Source # enumFromTo :: Char -> Char -> [ Char ] Source # enumFromThenTo :: Char -> Char -> Char -> [ Char ] Source #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool Source # (/=) :: Char -> Char -> Bool Source #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering Source # (<) :: Char -> Char -> Bool Source # (<=) :: Char -> Char -> Bool Source # (>) :: Char -> Char -> Bool Source # (>=) :: Char -> Char -> Bool Source # max :: Char -> Char -> Char Source # min :: Char -> Char -> Char Source #
Read Char	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char Source # readList :: ReadS [ Char ] Source # readPrec :: ReadPrec Char Source # readListPrec :: ReadPrec [ Char ] Source #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS Source # show :: Char -> String Source # showList :: [ Char ] -> ShowS Source #
Ix Char	Since: base-2.1
Instance details Defined in GHC.Ix Methods range :: ( Char , Char ) -> [ Char ] Source # index :: ( Char , Char ) -> Char -> Int Source # unsafeIndex :: ( Char , Char ) -> Char -> Int Source # inRange :: ( Char , Char ) -> Char -> Bool Source # rangeSize :: ( Char , Char ) -> Int Source # unsafeRangeSize :: ( Char , Char ) -> Int Source #
Hashable Char
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Char -> Int Source # hash :: Char -> Int Source #
Storable Char	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Char -> Int Source # alignment :: Char -> Int Source # peekElemOff :: Ptr Char -> Int -> IO Char Source # pokeElemOff :: Ptr Char -> Int -> Char -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Char Source # pokeByteOff :: Ptr b -> Int -> Char -> IO () Source # peek :: Ptr Char -> IO Char Source # poke :: Ptr Char -> Char -> IO () Source #
NFData Char
Instance details Defined in Control.DeepSeq Methods rnf :: Char -> () Source #
Buildable Char
Instance details Defined in Formatting.Buildable Methods build :: Char -> Builder Source #
Prim Char
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Char -> Int# Source # alignment# :: Char -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Char Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Char Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char #) Source # writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s Source #
Uniform Char
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Char Source #
UniformRange Char
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Char , Char ) -> g -> m Char Source #
ErrorList Char
Instance details Defined in Control.Monad.Trans.Error Methods listMsg :: String -> [ Char ] Source #
Unbox Char
Instance details Defined in Data.Vector.Unboxed.Base
HeapWords Char Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Char -> Int Source #
Lift Char
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Char -> Q Exp Source # liftTyped :: Char -> Q ( TExp Char ) Source #
IArray UArray Char
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Char -> (i, i) Source # numElements :: Ix i => UArray i Char -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Char )] -> UArray i Char unsafeAt :: Ix i => UArray i Char -> Int -> Char unsafeReplace :: Ix i => UArray i Char -> [( Int , Char )] -> UArray i Char unsafeAccum :: Ix i => ( Char -> e' -> Char ) -> UArray i Char -> [( Int , e')] -> UArray i Char unsafeAccumArray :: Ix i => ( Char -> e' -> Char ) -> Char -> (i, i) -> [( Int , e')] -> UArray i Char
Monad m => ToJSON m String
Instance details Defined in Text.JSON.Canonical.Class Methods toJSON :: String -> m JSValue Source #
ReportSchemaErrors m => FromJSON m String
Instance details Defined in Text.JSON.Canonical.Class Methods fromJSON :: JSValue -> m String Source #
Monad m => ToObjectKey m String
Instance details Defined in Text.JSON.Canonical.Class Methods toObjectKey :: String -> m JSString Source #
Monad m => FromObjectKey m String
Instance details Defined in Text.JSON.Canonical.Class Methods fromObjectKey :: JSString -> m ( Maybe String ) Source #
ConvertText String String
Instance details Defined in Protolude.ConvertText Methods toS :: String -> String Source #
ConvertText String Text
Instance details Defined in Protolude.ConvertText Methods toS :: String -> Text Source #
ConvertText String Text
Instance details Defined in Protolude.ConvertText Methods toS :: String -> Text Source #
ConvertText Text String
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> String Source #
ConvertText Text String
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> String Source #
Vector Vector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Char -> m ( Vector Char ) Source # basicUnsafeThaw :: PrimMonad m => Vector Char -> m ( Mutable Vector ( PrimState m) Char ) Source # basicLength :: Vector Char -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char Source # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Char -> Vector Char -> m () Source # elemseq :: Vector Char -> Char -> b -> b Source #
MVector MVector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char Source # basicOverlaps :: MVector s Char -> MVector s Char -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Char ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Char -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m ( MVector ( PrimState m) Char ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Char -> Int -> m Char Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Char -> Int -> Char -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Char -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Char -> Char -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Char -> MVector ( PrimState m) Char -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Char -> MVector ( PrimState m) Char -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Char -> Int -> m ( MVector ( PrimState m) Char ) Source #
Generic1 ( URec Char :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Char ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 ( URec Char ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Char ) a -> URec Char a Source #
Foldable ( UChar :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m Source # foldMap :: Monoid m => (a -> m) -> UChar a -> m Source # foldMap' :: Monoid m => (a -> m) -> UChar a -> m Source # foldr :: (a -> b -> b) -> b -> UChar a -> b Source # foldr' :: (a -> b -> b) -> b -> UChar a -> b Source # foldl :: (b -> a -> b) -> b -> UChar a -> b Source # foldl' :: (b -> a -> b) -> b -> UChar a -> b Source # foldr1 :: (a -> a -> a) -> UChar a -> a Source # foldl1 :: (a -> a -> a) -> UChar a -> a Source # toList :: UChar a -> [a] Source # null :: UChar a -> Bool Source # length :: UChar a -> Int Source # elem :: Eq a => a -> UChar a -> Bool Source # maximum :: Ord a => UChar a -> a Source # minimum :: Ord a => UChar a -> a Source # sum :: Num a => UChar a -> a Source # product :: Num a => UChar a -> a Source #
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) Source # sequenceA :: Applicative f => UChar (f a) -> f ( UChar a) Source # mapM :: Monad m => (a -> m b) -> UChar a -> m ( UChar b) Source # sequence :: Monad m => UChar (m a) -> m ( UChar a) Source #
Buildable [ Char ]
Instance details Defined in Formatting.Buildable Methods build :: [ Char ] -> Builder Source #
Print [ Char ]
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> [ Char ] -> m () Source # putStr :: MonadIO m => [ Char ] -> m () Source # hPutStrLn :: MonadIO m => Handle -> [ Char ] -> m () Source # putStrLn :: MonadIO m => [ Char ] -> m () Source # putErrLn :: MonadIO m => [ Char ] -> m () Source #
MArray ( STUArray s) Char ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Char -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Char -> ST s Int newArray :: Ix i => (i, i) -> Char -> ST s ( STUArray s i Char ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Char ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Char ) unsafeRead :: Ix i => STUArray s i Char -> Int -> ST s Char unsafeWrite :: Ix i => STUArray s i Char -> Int -> Char -> ST s ()
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 Source # (<$) :: a -> URec Char b -> URec Char a Source #
Eq ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool Source # (/=) :: URec Char p -> URec Char p -> Bool Source #
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 Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source # max :: URec Char p -> URec Char p -> URec Char p Source # min :: URec Char p -> URec Char p -> URec Char p Source #
Show ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS Source # show :: URec Char p -> String Source # showList :: [ URec Char p] -> ShowS Source #
Generic ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep ( URec Char p) x Source # to :: Rep ( URec Char p) x -> URec Char p Source #
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 )
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)
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 Source #

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

Constructors

D# Double#

Instances

Instances details

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 Source # (/=) :: Double -> Double -> Bool Source #
Floating Double	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double Source # exp :: Double -> Double Source # log :: Double -> Double Source # sqrt :: Double -> Double Source # (**) :: Double -> Double -> Double Source # logBase :: Double -> Double -> Double Source # sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # acosh :: Double -> Double Source # atanh :: Double -> Double Source # log1p :: Double -> Double Source # expm1 :: Double -> Double Source # log1pexp :: Double -> Double Source # log1mexp :: Double -> Double Source #
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 Source # (<) :: Double -> Double -> Bool Source # (<=) :: Double -> Double -> Bool Source # (>) :: Double -> Double -> Bool Source # (>=) :: Double -> Double -> Bool Source # max :: Double -> Double -> Double Source # min :: Double -> Double -> Double Source #
Read Double	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double Source # readList :: ReadS [ Double ] Source # readPrec :: ReadPrec Double Source # readListPrec :: ReadPrec [ Double ] Source #
RealFloat Double	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Double -> Integer Source # floatDigits :: Double -> Int Source # floatRange :: Double -> ( Int , Int ) Source # decodeFloat :: Double -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Double Source # exponent :: Double -> Int Source # significand :: Double -> Double Source # scaleFloat :: Int -> Double -> Double Source # isNaN :: Double -> Bool Source # isInfinite :: Double -> Bool Source # isDenormalized :: Double -> Bool Source # isNegativeZero :: Double -> Bool Source # isIEEE :: Double -> Bool Source # atan2 :: Double -> Double -> Double Source #
Hashable Double	Note : prior to `hashable-1.3.0.0` , `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Double -> Int Source # hash :: Double -> Int Source #
Storable Double	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Double -> Int Source # alignment :: Double -> Int Source # peekElemOff :: Ptr Double -> Int -> IO Double Source # pokeElemOff :: Ptr Double -> Int -> Double -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Double Source # pokeByteOff :: Ptr b -> Int -> Double -> IO () Source # peek :: Ptr Double -> IO Double Source # poke :: Ptr Double -> Double -> IO () Source #
NFData Double
Instance details Defined in Control.DeepSeq Methods rnf :: Double -> () Source #
Buildable Double
Instance details Defined in Formatting.Buildable Methods build :: Double -> Builder Source #
Prim Double
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Double -> Int# Source # alignment# :: Double -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Double Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Double #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Double Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Double #) Source # writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s Source #
UniformRange Double	See Floating point number caveats .
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Double , Double ) -> g -> m Double Source #
Unbox Double
Instance details Defined in Data.Vector.Unboxed.Base
Lift Double
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Double -> Q Exp Source # liftTyped :: Double -> Q ( TExp Double ) Source #
IArray UArray Double
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Double -> (i, i) Source # numElements :: Ix i => UArray i Double -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Double )] -> UArray i Double unsafeAt :: Ix i => UArray i Double -> Int -> Double unsafeReplace :: Ix i => UArray i Double -> [( Int , Double )] -> UArray i Double unsafeAccum :: Ix i => ( Double -> e' -> Double ) -> UArray i Double -> [( Int , e')] -> UArray i Double unsafeAccumArray :: Ix i => ( Double -> e' -> Double ) -> Double -> (i, i) -> [( Int , e')] -> UArray i Double
Vector Vector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Double -> m ( Vector Double ) Source # basicUnsafeThaw :: PrimMonad m => Vector Double -> m ( Mutable Vector ( PrimState m) Double ) Source # basicLength :: Vector Double -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double Source # basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Double -> Vector Double -> m () Source # elemseq :: Vector Double -> Double -> b -> b Source #
MVector MVector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double Source # basicOverlaps :: MVector s Double -> MVector s Double -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Double ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Double -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m ( MVector ( PrimState m) Double ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Double -> Int -> m Double Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Double -> Int -> Double -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Double -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Double -> Double -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Double -> MVector ( PrimState m) Double -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Double -> MVector ( PrimState m) Double -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Double -> Int -> m ( MVector ( PrimState m) Double ) Source #
Generic1 ( URec Double :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Double ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 ( URec Double ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Double ) a -> URec Double a Source #
Foldable ( UDouble :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m Source # foldMap :: Monoid m => (a -> m) -> UDouble a -> m Source # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m Source # foldr :: (a -> b -> b) -> b -> UDouble a -> b Source # foldr' :: (a -> b -> b) -> b -> UDouble a -> b Source # foldl :: (b -> a -> b) -> b -> UDouble a -> b Source # foldl' :: (b -> a -> b) -> b -> UDouble a -> b Source # foldr1 :: (a -> a -> a) -> UDouble a -> a Source # foldl1 :: (a -> a -> a) -> UDouble a -> a Source # toList :: UDouble a -> [a] Source # null :: UDouble a -> Bool Source # length :: UDouble a -> Int Source # elem :: Eq a => a -> UDouble a -> Bool Source # maximum :: Ord a => UDouble a -> a Source # minimum :: Ord a => UDouble a -> a Source # sum :: Num a => UDouble a -> a Source # product :: Num a => UDouble a -> a Source #
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) Source # sequenceA :: Applicative f => UDouble (f a) -> f ( UDouble a) Source # mapM :: Monad m => (a -> m b) -> UDouble a -> m ( UDouble b) Source # sequence :: Monad m => UDouble (m a) -> m ( UDouble a) Source #
MArray ( STUArray s) Double ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Double -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Double -> ST s Int newArray :: Ix i => (i, i) -> Double -> ST s ( STUArray s i Double ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Double ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Double ) unsafeRead :: Ix i => STUArray s i Double -> Int -> ST s Double unsafeWrite :: Ix i => STUArray s i Double -> Int -> Double -> ST s ()
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 Source # (<$) :: a -> URec Double b -> URec Double a Source #
Eq ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool Source # (/=) :: URec Double p -> URec Double p -> Bool Source #
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 Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source #
Show ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS Source # show :: URec Double p -> String Source # showList :: [ URec Double p] -> ShowS Source #
Generic ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep ( URec Double p) x Source # to :: Rep ( URec Double p) x -> URec Double p Source #
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 )
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)
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 Source #

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

Constructors

F# Float#

Instances

Instances details

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 substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool Source # (/=) :: Float -> Float -> Bool Source #
Floating Float	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float Source # exp :: Float -> Float Source # log :: Float -> Float Source # sqrt :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source # log1p :: Float -> Float Source # expm1 :: Float -> Float Source # log1pexp :: Float -> Float Source # log1mexp :: Float -> Float Source #
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 Source # (<) :: Float -> Float -> Bool Source # (<=) :: Float -> Float -> Bool Source # (>) :: Float -> Float -> Bool Source # (>=) :: Float -> Float -> Bool Source # max :: Float -> Float -> Float Source # min :: Float -> Float -> Float Source #
Read Float	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float Source # readList :: ReadS [ Float ] Source # readPrec :: ReadPrec Float Source # readListPrec :: ReadPrec [ Float ] Source #
RealFloat Float	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Float -> Integer Source # floatDigits :: Float -> Int Source # floatRange :: Float -> ( Int , Int ) Source # decodeFloat :: Float -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Float Source # exponent :: Float -> Int Source # significand :: Float -> Float Source # scaleFloat :: Int -> Float -> Float Source # isNaN :: Float -> Bool Source # isInfinite :: Float -> Bool Source # isDenormalized :: Float -> Bool Source # isNegativeZero :: Float -> Bool Source # isIEEE :: Float -> Bool Source # atan2 :: Float -> Float -> Float Source #
Hashable Float	Note : prior to `hashable-1.3.0.0` , `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Float -> Int Source # hash :: Float -> Int Source #
Storable Float	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Float -> Int Source # alignment :: Float -> Int Source # peekElemOff :: Ptr Float -> Int -> IO Float Source # pokeElemOff :: Ptr Float -> Int -> Float -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Float Source # pokeByteOff :: Ptr b -> Int -> Float -> IO () Source # peek :: Ptr Float -> IO Float Source # poke :: Ptr Float -> Float -> IO () Source #
NFData Float
Instance details Defined in Control.DeepSeq Methods rnf :: Float -> () Source #
Buildable Float
Instance details Defined in Formatting.Buildable Methods build :: Float -> Builder Source #
Prim Float
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Float -> Int# Source # alignment# :: Float -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Float Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Float #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Float Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Float #) Source # writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s Source #
UniformRange Float	See Floating point number caveats .
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Float , Float ) -> g -> m Float Source #
Unbox Float
Instance details Defined in Data.Vector.Unboxed.Base
HeapWords Float Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Float -> Int Source #
Lift Float
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Float -> Q Exp Source # liftTyped :: Float -> Q ( TExp Float ) Source #
IArray UArray Float
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Float -> (i, i) Source # numElements :: Ix i => UArray i Float -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Float )] -> UArray i Float unsafeAt :: Ix i => UArray i Float -> Int -> Float unsafeReplace :: Ix i => UArray i Float -> [( Int , Float )] -> UArray i Float unsafeAccum :: Ix i => ( Float -> e' -> Float ) -> UArray i Float -> [( Int , e')] -> UArray i Float unsafeAccumArray :: Ix i => ( Float -> e' -> Float ) -> Float -> (i, i) -> [( Int , e')] -> UArray i Float
Vector Vector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Float -> m ( Vector Float ) Source # basicUnsafeThaw :: PrimMonad m => Vector Float -> m ( Mutable Vector ( PrimState m) Float ) Source # basicLength :: Vector Float -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float Source # basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Float -> Vector Float -> m () Source # elemseq :: Vector Float -> Float -> b -> b Source #
MVector MVector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float Source # basicOverlaps :: MVector s Float -> MVector s Float -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Float ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Float -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m ( MVector ( PrimState m) Float ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Float -> Int -> m Float Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Float -> Int -> Float -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Float -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Float -> Float -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Float -> MVector ( PrimState m) Float -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Float -> MVector ( PrimState m) Float -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Float -> Int -> m ( MVector ( PrimState m) Float ) Source #
Generic1 ( URec Float :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Float ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 ( URec Float ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Float ) a -> URec Float a Source #
Foldable ( UFloat :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m Source # foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source # foldr :: (a -> b -> b) -> b -> UFloat a -> b Source # foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source # foldl :: (b -> a -> b) -> b -> UFloat a -> b Source # foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source # foldr1 :: (a -> a -> a) -> UFloat a -> a Source # foldl1 :: (a -> a -> a) -> UFloat a -> a Source # toList :: UFloat a -> [a] Source # null :: UFloat a -> Bool Source # length :: UFloat a -> Int Source # elem :: Eq a => a -> UFloat a -> Bool Source # maximum :: Ord a => UFloat a -> a Source # minimum :: Ord a => UFloat a -> a Source # sum :: Num a => UFloat a -> a Source # product :: Num a => UFloat a -> a Source #
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) Source # sequenceA :: Applicative f => UFloat (f a) -> f ( UFloat a) Source # mapM :: Monad m => (a -> m b) -> UFloat a -> m ( UFloat b) Source # sequence :: Monad m => UFloat (m a) -> m ( UFloat a) Source #
MArray ( STUArray s) Float ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Float -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Float -> ST s Int newArray :: Ix i => (i, i) -> Float -> ST s ( STUArray s i Float ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Float ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Float ) unsafeRead :: Ix i => STUArray s i Float -> Int -> ST s Float unsafeWrite :: Ix i => STUArray s i Float -> Int -> Float -> ST s ()
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 Source # (<$) :: a -> URec Float b -> URec Float a Source #
Eq ( URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool Source # (/=) :: URec Float p -> URec Float p -> Bool Source #
Ord ( URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source #
Show ( URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS Source # show :: URec Float p -> String Source # showList :: [ URec Float p] -> ShowS Source #
Generic ( URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep ( URec Float p) x Source # to :: Rep ( URec Float p) x -> URec Float p Source #
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 )
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 Source #

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

Instances

Instances details

Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int Source # maxBound :: Int Source #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int Source # pred :: Int -> Int Source # toEnum :: Int -> Int Source # fromEnum :: Int -> Int Source # enumFrom :: Int -> [ Int ] Source # enumFromThen :: Int -> Int -> [ Int ] Source # enumFromTo :: Int -> Int -> [ Int ] Source # enumFromThenTo :: Int -> Int -> Int -> [ Int ] Source #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool Source # (/=) :: Int -> Int -> Bool Source #
Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Int -> Int -> Int Source # rem :: Int -> Int -> Int Source # div :: Int -> Int -> Int Source # mod :: Int -> Int -> Int Source # quotRem :: Int -> Int -> ( Int , Int ) Source # divMod :: Int -> Int -> ( Int , Int ) Source # toInteger :: Int -> Integer Source #
Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int Source # (-) :: Int -> Int -> Int Source # (*) :: Int -> Int -> Int Source # negate :: Int -> Int Source # abs :: Int -> Int Source # signum :: Int -> Int Source # fromInteger :: Integer -> Int Source #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering Source # (<) :: Int -> Int -> Bool Source # (<=) :: Int -> Int -> Bool Source # (>) :: Int -> Int -> Bool Source # (>=) :: Int -> Int -> Bool Source # max :: Int -> Int -> Int Source # min :: Int -> Int -> Int Source #
Read Int	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int Source # readList :: ReadS [ Int ] Source # readPrec :: ReadPrec Int Source # readListPrec :: ReadPrec [ Int ] Source #
Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational Source #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS Source # show :: Int -> String Source # showList :: [ Int ] -> ShowS Source #
Ix Int	Since: base-2.1
Instance details Defined in GHC.Ix Methods range :: ( Int , Int ) -> [ Int ] Source # index :: ( Int , Int ) -> Int -> Int Source # unsafeIndex :: ( Int , Int ) -> Int -> Int Source # inRange :: ( Int , Int ) -> Int -> Bool Source # rangeSize :: ( Int , Int ) -> Int Source # unsafeRangeSize :: ( Int , Int ) -> Int Source #
Hashable Int
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int -> Int Source # hash :: Int -> Int Source #
Storable Int	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int -> Int Source # alignment :: Int -> Int Source # peekElemOff :: Ptr Int -> Int -> IO Int Source # pokeElemOff :: Ptr Int -> Int -> Int -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int Source # pokeByteOff :: Ptr b -> Int -> Int -> IO () Source # peek :: Ptr Int -> IO Int Source # poke :: Ptr Int -> Int -> IO () Source #
Bits Int	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Int -> Int -> Int Source # (.\|.) :: Int -> Int -> Int Source # xor :: Int -> Int -> Int Source # complement :: Int -> Int Source # shift :: Int -> Int -> Int Source # rotate :: Int -> Int -> Int Source # zeroBits :: Int Source # bit :: Int -> Int Source # setBit :: Int -> Int -> Int Source # clearBit :: Int -> Int -> Int Source # complementBit :: Int -> Int -> Int Source # testBit :: Int -> Int -> Bool Source # bitSizeMaybe :: Int -> Maybe Int Source # bitSize :: Int -> Int Source # isSigned :: Int -> Bool Source # shiftL :: Int -> Int -> Int Source # unsafeShiftL :: Int -> Int -> Int Source # shiftR :: Int -> Int -> Int Source # unsafeShiftR :: Int -> Int -> Int Source # rotateL :: Int -> Int -> Int Source # rotateR :: Int -> Int -> Int Source # popCount :: Int -> Int Source #
FiniteBits Int	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Int -> Int Source # countLeadingZeros :: Int -> Int Source # countTrailingZeros :: Int -> Int Source #
NFData Int
Instance details Defined in Control.DeepSeq Methods rnf :: Int -> () Source #
Buildable Int
Instance details Defined in Formatting.Buildable Methods build :: Int -> Builder Source #
Prim Int
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int -> Int# Source # alignment# :: Int -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Int Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Int Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int #) Source # writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s Source #
Uniform Int
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int Source #
UniformRange Int
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Int , Int ) -> g -> m Int Source #
ByteSource Int
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Int g -> Int -> g
Unbox Int
Instance details Defined in Data.Vector.Unboxed.Base
HeapWords Int Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Int -> Int Source #
Lift Int
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int -> Q Exp Source # liftTyped :: Int -> Q ( TExp Int ) Source #
IArray UArray Int
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int -> (i, i) Source # numElements :: Ix i => UArray i Int -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Int )] -> UArray i Int unsafeAt :: Ix i => UArray i Int -> Int -> Int unsafeReplace :: Ix i => UArray i Int -> [( Int , Int )] -> UArray i Int unsafeAccum :: Ix i => ( Int -> e' -> Int ) -> UArray i Int -> [( Int , e')] -> UArray i Int unsafeAccumArray :: Ix i => ( Int -> e' -> Int ) -> Int -> (i, i) -> [( Int , e')] -> UArray i Int
Vector Vector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int -> m ( Vector Int ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int -> m ( Mutable Vector ( PrimState m) Int ) Source # basicLength :: Vector Int -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int Source # basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int -> Vector Int -> m () Source # elemseq :: Vector Int -> Int -> b -> b Source #
MVector MVector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int Source # basicOverlaps :: MVector s Int -> MVector s Int -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m ( MVector ( PrimState m) Int ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int -> Int -> m Int Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int -> Int -> Int -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int -> Int -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int -> MVector ( PrimState m) Int -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int -> MVector ( PrimState m) Int -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int -> Int -> m ( MVector ( PrimState m) Int ) Source #
Generic1 ( URec Int :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Int ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 ( URec Int ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Int ) a -> URec Int a Source #
Foldable ( UInt :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m Source # foldMap :: Monoid m => (a -> m) -> UInt a -> m Source # foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source # foldr :: (a -> b -> b) -> b -> UInt a -> b Source # foldr' :: (a -> b -> b) -> b -> UInt a -> b Source # foldl :: (b -> a -> b) -> b -> UInt a -> b Source # foldl' :: (b -> a -> b) -> b -> UInt a -> b Source # foldr1 :: (a -> a -> a) -> UInt a -> a Source # foldl1 :: (a -> a -> a) -> UInt a -> a Source # toList :: UInt a -> [a] Source # null :: UInt a -> Bool Source # length :: UInt a -> Int Source # elem :: Eq a => a -> UInt a -> Bool Source # maximum :: Ord a => UInt a -> a Source # minimum :: Ord a => UInt a -> a Source # sum :: Num a => UInt a -> a Source # product :: Num a => UInt a -> a Source #
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) Source # sequenceA :: Applicative f => UInt (f a) -> f ( UInt a) Source # mapM :: Monad m => (a -> m b) -> UInt a -> m ( UInt b) Source # sequence :: Monad m => UInt (m a) -> m ( UInt a) Source #
MArray ( STUArray s) Int ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int -> ST s Int newArray :: Ix i => (i, i) -> Int -> ST s ( STUArray s i Int ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int ) unsafeRead :: Ix i => STUArray s i Int -> Int -> ST s Int unsafeWrite :: Ix i => STUArray s i Int -> Int -> Int -> ST s ()
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 Source # (<$) :: a -> URec Int b -> URec Int a Source #
Eq ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool Source # (/=) :: URec Int p -> URec Int p -> Bool Source #
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 Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source # max :: URec Int p -> URec Int p -> URec Int p Source # min :: URec Int p -> URec Int p -> URec Int p Source #
Show ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS Source # show :: URec Int p -> String Source # showList :: [ URec Int p] -> ShowS Source #
Generic ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep ( URec Int p) x Source # to :: Rep ( URec Int p) x -> URec Int p Source #
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# }
type ByteSink Int g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Int g = Takes4Bytes g
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 )
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)
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 Int8 Source #

8-bit signed integer type

Instances

Instances details

Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 Source # maxBound :: Int8 Source #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int8 -> Int8 Source # pred :: Int8 -> Int8 Source # toEnum :: Int -> Int8 Source # fromEnum :: Int8 -> Int Source # enumFrom :: Int8 -> [ Int8 ] Source # enumFromThen :: Int8 -> Int8 -> [ Int8 ] Source # enumFromTo :: Int8 -> Int8 -> [ Int8 ] Source # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [ Int8 ] Source #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool Source # (/=) :: Int8 -> Int8 -> Bool Source #
Integral Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int8 -> Int8 -> Int8 Source # rem :: Int8 -> Int8 -> Int8 Source # div :: Int8 -> Int8 -> Int8 Source # mod :: Int8 -> Int8 -> Int8 Source # quotRem :: Int8 -> Int8 -> ( Int8 , Int8 ) Source # divMod :: Int8 -> Int8 -> ( Int8 , Int8 ) Source # toInteger :: Int8 -> Integer Source #
Num Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int8 -> Int8 -> Int8 Source # (-) :: Int8 -> Int8 -> Int8 Source # (*) :: Int8 -> Int8 -> Int8 Source # negate :: Int8 -> Int8 Source # abs :: Int8 -> Int8 Source # signum :: Int8 -> Int8 Source # fromInteger :: Integer -> Int8 Source #
Ord Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int8 -> Int8 -> Ordering Source # (<) :: Int8 -> Int8 -> Bool Source # (<=) :: Int8 -> Int8 -> Bool Source # (>) :: Int8 -> Int8 -> Bool Source # (>=) :: Int8 -> Int8 -> Bool Source # max :: Int8 -> Int8 -> Int8 Source # min :: Int8 -> Int8 -> Int8 Source #
Read Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int8 Source # readList :: ReadS [ Int8 ] Source # readPrec :: ReadPrec Int8 Source # readListPrec :: ReadPrec [ Int8 ] Source #
Real Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int8 -> Rational Source #
Show Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int8 -> ShowS Source # show :: Int8 -> String Source # showList :: [ Int8 ] -> ShowS Source #
Ix Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: ( Int8 , Int8 ) -> [ Int8 ] Source # index :: ( Int8 , Int8 ) -> Int8 -> Int Source # unsafeIndex :: ( Int8 , Int8 ) -> Int8 -> Int Source # inRange :: ( Int8 , Int8 ) -> Int8 -> Bool Source # rangeSize :: ( Int8 , Int8 ) -> Int Source # unsafeRangeSize :: ( Int8 , Int8 ) -> Int Source #
Hashable Int8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int8 -> Int Source # hash :: Int8 -> Int Source #
Storable Int8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int8 -> Int Source # alignment :: Int8 -> Int Source # peekElemOff :: Ptr Int8 -> Int -> IO Int8 Source # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int8 Source # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () Source # peek :: Ptr Int8 -> IO Int8 Source # poke :: Ptr Int8 -> Int8 -> IO () Source #
Bits Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int8 -> Int8 -> Int8 Source # (.\|.) :: Int8 -> Int8 -> Int8 Source # xor :: Int8 -> Int8 -> Int8 Source # complement :: Int8 -> Int8 Source # shift :: Int8 -> Int -> Int8 Source # rotate :: Int8 -> Int -> Int8 Source # zeroBits :: Int8 Source # bit :: Int -> Int8 Source # setBit :: Int8 -> Int -> Int8 Source # clearBit :: Int8 -> Int -> Int8 Source # complementBit :: Int8 -> Int -> Int8 Source # testBit :: Int8 -> Int -> Bool Source # bitSizeMaybe :: Int8 -> Maybe Int Source # bitSize :: Int8 -> Int Source # isSigned :: Int8 -> Bool Source # shiftL :: Int8 -> Int -> Int8 Source # unsafeShiftL :: Int8 -> Int -> Int8 Source # shiftR :: Int8 -> Int -> Int8 Source # unsafeShiftR :: Int8 -> Int -> Int8 Source # rotateL :: Int8 -> Int -> Int8 Source # rotateR :: Int8 -> Int -> Int8 Source # popCount :: Int8 -> Int Source #
FiniteBits Int8	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int8 -> Int Source # countLeadingZeros :: Int8 -> Int Source # countTrailingZeros :: Int8 -> Int Source #
NFData Int8
Instance details Defined in Control.DeepSeq Methods rnf :: Int8 -> () Source #
Buildable Int8
Instance details Defined in Formatting.Buildable Methods build :: Int8 -> Builder Source #
Prim Int8
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int8 -> Int# Source # alignment# :: Int8 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Int8 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int8 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Int8 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int8 #) Source # writeOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Int8 -> State# s -> State# s Source #
Uniform Int8
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int8 Source #
UniformRange Int8
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Int8 , Int8 ) -> g -> m Int8 Source #
Unbox Int8
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int8 -> Q Exp Source # liftTyped :: Int8 -> Q ( TExp Int8 ) Source #
IArray UArray Int8
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int8 -> (i, i) Source # numElements :: Ix i => UArray i Int8 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Int8 )] -> UArray i Int8 unsafeAt :: Ix i => UArray i Int8 -> Int -> Int8 unsafeReplace :: Ix i => UArray i Int8 -> [( Int , Int8 )] -> UArray i Int8 unsafeAccum :: Ix i => ( Int8 -> e' -> Int8 ) -> UArray i Int8 -> [( Int , e')] -> UArray i Int8 unsafeAccumArray :: Ix i => ( Int8 -> e' -> Int8 ) -> Int8 -> (i, i) -> [( Int , e')] -> UArray i Int8
Vector Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int8 -> m ( Vector Int8 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m ( Mutable Vector ( PrimState m) Int8 ) Source # basicLength :: Vector Int8 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 Source # basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int8 -> Vector Int8 -> m () Source # elemseq :: Vector Int8 -> Int8 -> b -> b Source #
MVector MVector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int8 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8 Source # basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int8 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int8 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m ( MVector ( PrimState m) Int8 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int8 -> Int -> m Int8 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int8 -> Int -> Int8 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int8 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int8 -> Int8 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int8 -> MVector ( PrimState m) Int8 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int8 -> MVector ( PrimState m) Int8 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int8 -> Int -> m ( MVector ( PrimState m) Int8 ) Source #
MArray ( STUArray s) Int8 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int8 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int8 -> ST s Int newArray :: Ix i => (i, i) -> Int8 -> ST s ( STUArray s i Int8 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int8 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int8 ) unsafeRead :: Ix i => STUArray s i Int8 -> Int -> ST s Int8 unsafeWrite :: Ix i => STUArray s i Int8 -> Int -> Int8 -> ST s ()
newtype Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int8 = V_Int8 ( Vector Int8 )
newtype MVector s Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int8 = MV_Int8 ( MVector s Int8 )

data Int16 Source #

16-bit signed integer type

Instances

Instances details

Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 Source # maxBound :: Int16 Source #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 Source # pred :: Int16 -> Int16 Source # toEnum :: Int -> Int16 Source # fromEnum :: Int16 -> Int Source # enumFrom :: Int16 -> [ Int16 ] Source # enumFromThen :: Int16 -> Int16 -> [ Int16 ] Source # enumFromTo :: Int16 -> Int16 -> [ Int16 ] Source # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [ Int16 ] Source #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool Source # (/=) :: Int16 -> Int16 -> Bool Source #
Integral Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int16 -> Int16 -> Int16 Source # rem :: Int16 -> Int16 -> Int16 Source # div :: Int16 -> Int16 -> Int16 Source # mod :: Int16 -> Int16 -> Int16 Source # quotRem :: Int16 -> Int16 -> ( Int16 , Int16 ) Source # divMod :: Int16 -> Int16 -> ( Int16 , Int16 ) Source # toInteger :: Int16 -> Integer Source #
Num Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int16 -> Int16 -> Int16 Source # (-) :: Int16 -> Int16 -> Int16 Source # (*) :: Int16 -> Int16 -> Int16 Source # negate :: Int16 -> Int16 Source # abs :: Int16 -> Int16 Source # signum :: Int16 -> Int16 Source # fromInteger :: Integer -> Int16 Source #
Ord Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int16 -> Int16 -> Ordering Source # (<) :: Int16 -> Int16 -> Bool Source # (<=) :: Int16 -> Int16 -> Bool Source # (>) :: Int16 -> Int16 -> Bool Source # (>=) :: Int16 -> Int16 -> Bool Source # max :: Int16 -> Int16 -> Int16 Source # min :: Int16 -> Int16 -> Int16 Source #
Read Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int16 Source # readList :: ReadS [ Int16 ] Source # readPrec :: ReadPrec Int16 Source # readListPrec :: ReadPrec [ Int16 ] Source #
Real Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int16 -> Rational Source #
Show Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int16 -> ShowS Source # show :: Int16 -> String Source # showList :: [ Int16 ] -> ShowS Source #
Ix Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: ( Int16 , Int16 ) -> [ Int16 ] Source # index :: ( Int16 , Int16 ) -> Int16 -> Int Source # unsafeIndex :: ( Int16 , Int16 ) -> Int16 -> Int Source # inRange :: ( Int16 , Int16 ) -> Int16 -> Bool Source # rangeSize :: ( Int16 , Int16 ) -> Int Source # unsafeRangeSize :: ( Int16 , Int16 ) -> Int Source #
Hashable Int16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int16 -> Int Source # hash :: Int16 -> Int Source #
Storable Int16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int16 -> Int Source # alignment :: Int16 -> Int Source # peekElemOff :: Ptr Int16 -> Int -> IO Int16 Source # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int16 Source # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () Source # peek :: Ptr Int16 -> IO Int16 Source # poke :: Ptr Int16 -> Int16 -> IO () Source #
Bits Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int16 -> Int16 -> Int16 Source # (.\|.) :: Int16 -> Int16 -> Int16 Source # xor :: Int16 -> Int16 -> Int16 Source # complement :: Int16 -> Int16 Source # shift :: Int16 -> Int -> Int16 Source # rotate :: Int16 -> Int -> Int16 Source # zeroBits :: Int16 Source # bit :: Int -> Int16 Source # setBit :: Int16 -> Int -> Int16 Source # clearBit :: Int16 -> Int -> Int16 Source # complementBit :: Int16 -> Int -> Int16 Source # testBit :: Int16 -> Int -> Bool Source # bitSizeMaybe :: Int16 -> Maybe Int Source # bitSize :: Int16 -> Int Source # isSigned :: Int16 -> Bool Source # shiftL :: Int16 -> Int -> Int16 Source # unsafeShiftL :: Int16 -> Int -> Int16 Source # shiftR :: Int16 -> Int -> Int16 Source # unsafeShiftR :: Int16 -> Int -> Int16 Source # rotateL :: Int16 -> Int -> Int16 Source # rotateR :: Int16 -> Int -> Int16 Source # popCount :: Int16 -> Int Source #
FiniteBits Int16	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int16 -> Int Source # countLeadingZeros :: Int16 -> Int Source # countTrailingZeros :: Int16 -> Int Source #
NFData Int16
Instance details Defined in Control.DeepSeq Methods rnf :: Int16 -> () Source #
Buildable Int16
Instance details Defined in Formatting.Buildable Methods build :: Int16 -> Builder Source #
Prim Int16
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int16 -> Int# Source # alignment# :: Int16 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Int16 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Int16 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int16 #) Source # writeOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Int16 -> State# s -> State# s Source #
Uniform Int16
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int16 Source #
UniformRange Int16
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Int16 , Int16 ) -> g -> m Int16 Source #
Unbox Int16
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int16 -> Q Exp Source # liftTyped :: Int16 -> Q ( TExp Int16 ) Source #
IArray UArray Int16
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int16 -> (i, i) Source # numElements :: Ix i => UArray i Int16 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Int16 )] -> UArray i Int16 unsafeAt :: Ix i => UArray i Int16 -> Int -> Int16 unsafeReplace :: Ix i => UArray i Int16 -> [( Int , Int16 )] -> UArray i Int16 unsafeAccum :: Ix i => ( Int16 -> e' -> Int16 ) -> UArray i Int16 -> [( Int , e')] -> UArray i Int16 unsafeAccumArray :: Ix i => ( Int16 -> e' -> Int16 ) -> Int16 -> (i, i) -> [( Int , e')] -> UArray i Int16
Vector Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int16 -> m ( Vector Int16 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m ( Mutable Vector ( PrimState m) Int16 ) Source # basicLength :: Vector Int16 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 Source # basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int16 -> Vector Int16 -> m () Source # elemseq :: Vector Int16 -> Int16 -> b -> b Source #
MVector MVector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int16 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16 Source # basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int16 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int16 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m ( MVector ( PrimState m) Int16 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int16 -> Int -> m Int16 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int16 -> Int -> Int16 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int16 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int16 -> Int16 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int16 -> MVector ( PrimState m) Int16 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int16 -> MVector ( PrimState m) Int16 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int16 -> Int -> m ( MVector ( PrimState m) Int16 ) Source #
MArray ( STUArray s) Int16 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int16 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int16 -> ST s Int newArray :: Ix i => (i, i) -> Int16 -> ST s ( STUArray s i Int16 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int16 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int16 ) unsafeRead :: Ix i => STUArray s i Int16 -> Int -> ST s Int16 unsafeWrite :: Ix i => STUArray s i Int16 -> Int -> Int16 -> ST s ()
newtype Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int16 = V_Int16 ( Vector Int16 )
newtype MVector s Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int16 = MV_Int16 ( MVector s Int16 )

data Int32 Source #

32-bit signed integer type

Instances

Instances details

Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 Source # maxBound :: Int32 Source #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 Source # pred :: Int32 -> Int32 Source # toEnum :: Int -> Int32 Source # fromEnum :: Int32 -> Int Source # enumFrom :: Int32 -> [ Int32 ] Source # enumFromThen :: Int32 -> Int32 -> [ Int32 ] Source # enumFromTo :: Int32 -> Int32 -> [ Int32 ] Source # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [ Int32 ] Source #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool Source # (/=) :: Int32 -> Int32 -> Bool Source #
Integral Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int32 -> Int32 -> Int32 Source # rem :: Int32 -> Int32 -> Int32 Source # div :: Int32 -> Int32 -> Int32 Source # mod :: Int32 -> Int32 -> Int32 Source # quotRem :: Int32 -> Int32 -> ( Int32 , Int32 ) Source # divMod :: Int32 -> Int32 -> ( Int32 , Int32 ) Source # toInteger :: Int32 -> Integer Source #
Num Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int32 -> Int32 -> Int32 Source # (-) :: Int32 -> Int32 -> Int32 Source # (*) :: Int32 -> Int32 -> Int32 Source # negate :: Int32 -> Int32 Source # abs :: Int32 -> Int32 Source # signum :: Int32 -> Int32 Source # fromInteger :: Integer -> Int32 Source #
Ord Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int32 -> Int32 -> Ordering Source # (<) :: Int32 -> Int32 -> Bool Source # (<=) :: Int32 -> Int32 -> Bool Source # (>) :: Int32 -> Int32 -> Bool Source # (>=) :: Int32 -> Int32 -> Bool Source # max :: Int32 -> Int32 -> Int32 Source # min :: Int32 -> Int32 -> Int32 Source #
Read Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int32 Source # readList :: ReadS [ Int32 ] Source # readPrec :: ReadPrec Int32 Source # readListPrec :: ReadPrec [ Int32 ] Source #
Real Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int32 -> Rational Source #
Show Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int32 -> ShowS Source # show :: Int32 -> String Source # showList :: [ Int32 ] -> ShowS Source #
Ix Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: ( Int32 , Int32 ) -> [ Int32 ] Source # index :: ( Int32 , Int32 ) -> Int32 -> Int Source # unsafeIndex :: ( Int32 , Int32 ) -> Int32 -> Int Source # inRange :: ( Int32 , Int32 ) -> Int32 -> Bool Source # rangeSize :: ( Int32 , Int32 ) -> Int Source # unsafeRangeSize :: ( Int32 , Int32 ) -> Int Source #
Hashable Int32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int32 -> Int Source # hash :: Int32 -> Int Source #
Storable Int32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int32 -> Int Source # alignment :: Int32 -> Int Source # peekElemOff :: Ptr Int32 -> Int -> IO Int32 Source # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int32 Source # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () Source # peek :: Ptr Int32 -> IO Int32 Source # poke :: Ptr Int32 -> Int32 -> IO () Source #
Bits Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int32 -> Int32 -> Int32 Source # (.\|.) :: Int32 -> Int32 -> Int32 Source # xor :: Int32 -> Int32 -> Int32 Source # complement :: Int32 -> Int32 Source # shift :: Int32 -> Int -> Int32 Source # rotate :: Int32 -> Int -> Int32 Source # zeroBits :: Int32 Source # bit :: Int -> Int32 Source # setBit :: Int32 -> Int -> Int32 Source # clearBit :: Int32 -> Int -> Int32 Source # complementBit :: Int32 -> Int -> Int32 Source # testBit :: Int32 -> Int -> Bool Source # bitSizeMaybe :: Int32 -> Maybe Int Source # bitSize :: Int32 -> Int Source # isSigned :: Int32 -> Bool Source # shiftL :: Int32 -> Int -> Int32 Source # unsafeShiftL :: Int32 -> Int -> Int32 Source # shiftR :: Int32 -> Int -> Int32 Source # unsafeShiftR :: Int32 -> Int -> Int32 Source # rotateL :: Int32 -> Int -> Int32 Source # rotateR :: Int32 -> Int -> Int32 Source # popCount :: Int32 -> Int Source #
FiniteBits Int32	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int32 -> Int Source # countLeadingZeros :: Int32 -> Int Source # countTrailingZeros :: Int32 -> Int Source #
NFData Int32
Instance details Defined in Control.DeepSeq Methods rnf :: Int32 -> () Source #
Buildable Int32
Instance details Defined in Formatting.Buildable Methods build :: Int32 -> Builder Source #
Prim Int32
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int32 -> Int# Source # alignment# :: Int32 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Int32 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Int32 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int32 #) Source # writeOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Int32 -> State# s -> State# s Source #
Uniform Int32
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int32 Source #
UniformRange Int32
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Int32 , Int32 ) -> g -> m Int32 Source #
Unbox Int32
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int32 -> Q Exp Source # liftTyped :: Int32 -> Q ( TExp Int32 ) Source #
IArray UArray Int32
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int32 -> (i, i) Source # numElements :: Ix i => UArray i Int32 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Int32 )] -> UArray i Int32 unsafeAt :: Ix i => UArray i Int32 -> Int -> Int32 unsafeReplace :: Ix i => UArray i Int32 -> [( Int , Int32 )] -> UArray i Int32 unsafeAccum :: Ix i => ( Int32 -> e' -> Int32 ) -> UArray i Int32 -> [( Int , e')] -> UArray i Int32 unsafeAccumArray :: Ix i => ( Int32 -> e' -> Int32 ) -> Int32 -> (i, i) -> [( Int , e')] -> UArray i Int32
Monad m => ToJSON m Int32 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods toJSON :: Int32 -> m JSValue Source #
ReportSchemaErrors m => FromJSON m Int32 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods fromJSON :: JSValue -> m Int32 Source #
Vector Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int32 -> m ( Vector Int32 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m ( Mutable Vector ( PrimState m) Int32 ) Source # basicLength :: Vector Int32 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 Source # basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int32 -> Vector Int32 -> m () Source # elemseq :: Vector Int32 -> Int32 -> b -> b Source #
MVector MVector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int32 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 Source # basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int32 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int32 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m ( MVector ( PrimState m) Int32 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int32 -> Int -> m Int32 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int32 -> Int -> Int32 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int32 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int32 -> Int32 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int32 -> MVector ( PrimState m) Int32 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int32 -> MVector ( PrimState m) Int32 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int32 -> Int -> m ( MVector ( PrimState m) Int32 ) Source #
MArray ( STUArray s) Int32 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int32 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int32 -> ST s Int newArray :: Ix i => (i, i) -> Int32 -> ST s ( STUArray s i Int32 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int32 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int32 ) unsafeRead :: Ix i => STUArray s i Int32 -> Int -> ST s Int32 unsafeWrite :: Ix i => STUArray s i Int32 -> Int -> Int32 -> ST s ()
newtype Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int32 = V_Int32 ( Vector Int32 )
newtype MVector s Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int32 = MV_Int32 ( MVector s Int32 )

data Int64 Source #

64-bit signed integer type

Instances

Instances details

Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 Source # maxBound :: Int64 Source #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 Source # pred :: Int64 -> Int64 Source # toEnum :: Int -> Int64 Source # fromEnum :: Int64 -> Int Source # enumFrom :: Int64 -> [ Int64 ] Source # enumFromThen :: Int64 -> Int64 -> [ Int64 ] Source # enumFromTo :: Int64 -> Int64 -> [ Int64 ] Source # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [ Int64 ] Source #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool Source # (/=) :: Int64 -> Int64 -> Bool Source #
Integral Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int64 -> Int64 -> Int64 Source # rem :: Int64 -> Int64 -> Int64 Source # div :: Int64 -> Int64 -> Int64 Source # mod :: Int64 -> Int64 -> Int64 Source # quotRem :: Int64 -> Int64 -> ( Int64 , Int64 ) Source # divMod :: Int64 -> Int64 -> ( Int64 , Int64 ) Source # toInteger :: Int64 -> Integer Source #
Num Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int64 -> Int64 -> Int64 Source # (-) :: Int64 -> Int64 -> Int64 Source # (*) :: Int64 -> Int64 -> Int64 Source # negate :: Int64 -> Int64 Source # abs :: Int64 -> Int64 Source # signum :: Int64 -> Int64 Source # fromInteger :: Integer -> Int64 Source #
Ord Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int64 -> Int64 -> Ordering Source # (<) :: Int64 -> Int64 -> Bool Source # (<=) :: Int64 -> Int64 -> Bool Source # (>) :: Int64 -> Int64 -> Bool Source # (>=) :: Int64 -> Int64 -> Bool Source # max :: Int64 -> Int64 -> Int64 Source # min :: Int64 -> Int64 -> Int64 Source #
Read Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int64 Source # readList :: ReadS [ Int64 ] Source # readPrec :: ReadPrec Int64 Source # readListPrec :: ReadPrec [ Int64 ] Source #
Real Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int64 -> Rational Source #
Show Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int64 -> ShowS Source # show :: Int64 -> String Source # showList :: [ Int64 ] -> ShowS Source #
Ix Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: ( Int64 , Int64 ) -> [ Int64 ] Source # index :: ( Int64 , Int64 ) -> Int64 -> Int Source # unsafeIndex :: ( Int64 , Int64 ) -> Int64 -> Int Source # inRange :: ( Int64 , Int64 ) -> Int64 -> Bool Source # rangeSize :: ( Int64 , Int64 ) -> Int Source # unsafeRangeSize :: ( Int64 , Int64 ) -> Int Source #
Hashable Int64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int64 -> Int Source # hash :: Int64 -> Int Source #
Storable Int64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int64 -> Int Source # alignment :: Int64 -> Int Source # peekElemOff :: Ptr Int64 -> Int -> IO Int64 Source # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int64 Source # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () Source # peek :: Ptr Int64 -> IO Int64 Source # poke :: Ptr Int64 -> Int64 -> IO () Source #
Bits Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int64 -> Int64 -> Int64 Source # (.\|.) :: Int64 -> Int64 -> Int64 Source # xor :: Int64 -> Int64 -> Int64 Source # complement :: Int64 -> Int64 Source # shift :: Int64 -> Int -> Int64 Source # rotate :: Int64 -> Int -> Int64 Source # zeroBits :: Int64 Source # bit :: Int -> Int64 Source # setBit :: Int64 -> Int -> Int64 Source # clearBit :: Int64 -> Int -> Int64 Source # complementBit :: Int64 -> Int -> Int64 Source # testBit :: Int64 -> Int -> Bool Source # bitSizeMaybe :: Int64 -> Maybe Int Source # bitSize :: Int64 -> Int Source # isSigned :: Int64 -> Bool Source # shiftL :: Int64 -> Int -> Int64 Source # unsafeShiftL :: Int64 -> Int -> Int64 Source # shiftR :: Int64 -> Int -> Int64 Source # unsafeShiftR :: Int64 -> Int -> Int64 Source # rotateL :: Int64 -> Int -> Int64 Source # rotateR :: Int64 -> Int -> Int64 Source # popCount :: Int64 -> Int Source #
FiniteBits Int64	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int64 -> Int Source # countLeadingZeros :: Int64 -> Int Source # countTrailingZeros :: Int64 -> Int Source #
NFData Int64
Instance details Defined in Control.DeepSeq Methods rnf :: Int64 -> () Source #
Buildable Int64
Instance details Defined in Formatting.Buildable Methods build :: Int64 -> Builder Source #
Prim Int64
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int64 -> Int# Source # alignment# :: Int64 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Int64 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Int64 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int64 #) Source # writeOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Int64 -> State# s -> State# s Source #
Uniform Int64
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int64 Source #
UniformRange Int64
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Int64 , Int64 ) -> g -> m Int64 Source #
Unbox Int64
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int64 -> Q Exp Source # liftTyped :: Int64 -> Q ( TExp Int64 ) Source #
IArray UArray Int64
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int64 -> (i, i) Source # numElements :: Ix i => UArray i Int64 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Int64 )] -> UArray i Int64 unsafeAt :: Ix i => UArray i Int64 -> Int -> Int64 unsafeReplace :: Ix i => UArray i Int64 -> [( Int , Int64 )] -> UArray i Int64 unsafeAccum :: Ix i => ( Int64 -> e' -> Int64 ) -> UArray i Int64 -> [( Int , e')] -> UArray i Int64 unsafeAccumArray :: Ix i => ( Int64 -> e' -> Int64 ) -> Int64 -> (i, i) -> [( Int , e')] -> UArray i Int64
Vector Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int64 -> m ( Vector Int64 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m ( Mutable Vector ( PrimState m) Int64 ) Source # basicLength :: Vector Int64 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 Source # basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int64 -> Vector Int64 -> m () Source # elemseq :: Vector Int64 -> Int64 -> b -> b Source #
MVector MVector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int64 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 Source # basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int64 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int64 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m ( MVector ( PrimState m) Int64 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int64 -> Int -> m Int64 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int64 -> Int -> Int64 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int64 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int64 -> Int64 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int64 -> MVector ( PrimState m) Int64 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int64 -> MVector ( PrimState m) Int64 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int64 -> Int -> m ( MVector ( PrimState m) Int64 ) Source #
MArray ( STUArray s) Int64 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int64 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int64 -> ST s Int newArray :: Ix i => (i, i) -> Int64 -> ST s ( STUArray s i Int64 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int64 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int64 ) unsafeRead :: Ix i => STUArray s i Int64 -> Int -> ST s Int64 unsafeWrite :: Ix i => STUArray s i Int64 -> Int -> Int64 -> ST s ()
newtype Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int64 = V_Int64 ( Vector Int64 )
newtype MVector s Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int64 = MV_Int64 ( MVector s Int64 )

data Integer Source #

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

For more information about this type's representation, see the comments in its implementation.

Instances

Instances details

Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer Source # pred :: Integer -> Integer Source # toEnum :: Int -> Integer Source # fromEnum :: Integer -> Int Source # enumFrom :: Integer -> [ Integer ] Source # enumFromThen :: Integer -> Integer -> [ Integer ] Source # enumFromTo :: Integer -> Integer -> [ Integer ] Source # enumFromThenTo :: Integer -> Integer -> Integer -> [ Integer ] Source #
Eq Integer
Instance details Defined in GHC.Integer.Type Methods (==) :: Integer -> Integer -> Bool Source # (/=) :: Integer -> Integer -> Bool Source #
Integral Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Integer -> Integer -> Integer Source # rem :: Integer -> Integer -> Integer Source # div :: Integer -> Integer -> Integer Source # mod :: Integer -> Integer -> Integer Source # quotRem :: Integer -> Integer -> ( Integer , Integer ) Source # divMod :: Integer -> Integer -> ( Integer , Integer ) Source # toInteger :: Integer -> Integer Source #
Num Integer	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Integer -> Integer -> Integer Source # (-) :: Integer -> Integer -> Integer Source # (*) :: Integer -> Integer -> Integer Source # negate :: Integer -> Integer Source # abs :: Integer -> Integer Source # signum :: Integer -> Integer Source # fromInteger :: Integer -> Integer Source #
Ord Integer
Instance details Defined in GHC.Integer.Type Methods compare :: Integer -> Integer -> Ordering Source # (<) :: Integer -> Integer -> Bool Source # (<=) :: Integer -> Integer -> Bool Source # (>) :: Integer -> Integer -> Bool Source # (>=) :: Integer -> Integer -> Bool Source # max :: Integer -> Integer -> Integer Source # min :: Integer -> Integer -> Integer Source #
Read Integer	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Integer Source # readList :: ReadS [ Integer ] Source # readPrec :: ReadPrec Integer Source # readListPrec :: ReadPrec [ Integer ] Source #
Real Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Integer -> Rational Source #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS Source # show :: Integer -> String Source # showList :: [ Integer ] -> ShowS Source #
Ix Integer	Since: base-2.1
Instance details Defined in GHC.Ix Methods range :: ( Integer , Integer ) -> [ Integer ] Source # index :: ( Integer , Integer ) -> Integer -> Int Source # unsafeIndex :: ( Integer , Integer ) -> Integer -> Int Source # inRange :: ( Integer , Integer ) -> Integer -> Bool Source # rangeSize :: ( Integer , Integer ) -> Int Source # unsafeRangeSize :: ( Integer , Integer ) -> Int Source #
Hashable Integer
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Integer -> Int Source # hash :: Integer -> Int Source #
Bits Integer	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Integer -> Integer -> Integer Source # (.\|.) :: Integer -> Integer -> Integer Source # xor :: Integer -> Integer -> Integer Source # complement :: Integer -> Integer Source # shift :: Integer -> Int -> Integer Source # rotate :: Integer -> Int -> Integer Source # zeroBits :: Integer Source # bit :: Int -> Integer Source # setBit :: Integer -> Int -> Integer Source # clearBit :: Integer -> Int -> Integer Source # complementBit :: Integer -> Int -> Integer Source # testBit :: Integer -> Int -> Bool Source # bitSizeMaybe :: Integer -> Maybe Int Source # bitSize :: Integer -> Int Source # isSigned :: Integer -> Bool Source # shiftL :: Integer -> Int -> Integer Source # unsafeShiftL :: Integer -> Int -> Integer Source # shiftR :: Integer -> Int -> Integer Source # unsafeShiftR :: Integer -> Int -> Integer Source # rotateL :: Integer -> Int -> Integer Source # rotateR :: Integer -> Int -> Integer Source # popCount :: Integer -> Int Source #
NFData Integer
Instance details Defined in Control.DeepSeq Methods rnf :: Integer -> () Source #
Buildable Integer
Instance details Defined in Formatting.Buildable Methods build :: Integer -> Builder Source #
UniformRange Integer
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Integer , Integer ) -> g -> m Integer Source #
HeapWords Integer Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Integer -> Int Source #
Lift Integer
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Integer -> Q Exp Source # liftTyped :: Integer -> Q ( TExp Integer ) Source #
Monad m => ToJSON m Integer Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods toJSON :: Integer -> m JSValue Source #
ReportSchemaErrors m => FromJSON m Integer Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods fromJSON :: JSValue -> m Integer Source #

data Natural Source #

Type representing arbitrary-precision non-negative integers.

>>> 2^100 :: Natural
1267650600228229401496703205376

Operations whose result would be negative throw ( Underflow :: ArithException ) ,

>>> -1 :: Natural
*** Exception: arithmetic underflow

Since: base-4.8.0.0

Instances

Instances details

Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural Source # pred :: Natural -> Natural Source # toEnum :: Int -> Natural Source # fromEnum :: Natural -> Int Source # enumFrom :: Natural -> [ Natural ] Source # enumFromThen :: Natural -> Natural -> [ Natural ] Source # enumFromTo :: Natural -> Natural -> [ Natural ] Source # enumFromThenTo :: Natural -> Natural -> Natural -> [ Natural ] Source #
Eq Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Natural Methods (==) :: Natural -> Natural -> Bool Source # (/=) :: Natural -> Natural -> Bool Source #
Integral Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural Source # rem :: Natural -> Natural -> Natural Source # div :: Natural -> Natural -> Natural Source # mod :: Natural -> Natural -> Natural Source # quotRem :: Natural -> Natural -> ( Natural , Natural ) Source # divMod :: Natural -> Natural -> ( Natural , Natural ) Source # toInteger :: Natural -> Integer Source #
Num Natural	Note that `Natural` 's `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural Source # (-) :: Natural -> Natural -> Natural Source # (*) :: Natural -> Natural -> Natural Source # negate :: Natural -> Natural Source # abs :: Natural -> Natural Source # signum :: Natural -> Natural Source # fromInteger :: Integer -> Natural Source #
Ord Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Natural Methods compare :: Natural -> Natural -> Ordering Source # (<) :: Natural -> Natural -> Bool Source # (<=) :: Natural -> Natural -> Bool Source # (>) :: Natural -> Natural -> Bool Source # (>=) :: Natural -> Natural -> Bool Source # max :: Natural -> Natural -> Natural Source # min :: Natural -> Natural -> Natural Source #
Read Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Natural Source # readList :: ReadS [ Natural ] Source # readPrec :: ReadPrec Natural Source # readListPrec :: ReadPrec [ Natural ] Source #
Real Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational Source #
Show Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS Source # show :: Natural -> String Source # showList :: [ Natural ] -> ShowS Source #
Ix Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Ix Methods range :: ( Natural , Natural ) -> [ Natural ] Source # index :: ( Natural , Natural ) -> Natural -> Int Source # unsafeIndex :: ( Natural , Natural ) -> Natural -> Int Source # inRange :: ( Natural , Natural ) -> Natural -> Bool Source # rangeSize :: ( Natural , Natural ) -> Int Source # unsafeRangeSize :: ( Natural , Natural ) -> Int Source #
Hashable Natural
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int Source # hash :: Natural -> Int Source #
Bits Natural	Since: base-4.8.0
Instance details Defined in Data.Bits Methods (.&.) :: Natural -> Natural -> Natural Source # (.\|.) :: Natural -> Natural -> Natural Source # xor :: Natural -> Natural -> Natural Source # complement :: Natural -> Natural Source # shift :: Natural -> Int -> Natural Source # rotate :: Natural -> Int -> Natural Source # zeroBits :: Natural Source # bit :: Int -> Natural Source # setBit :: Natural -> Int -> Natural Source # clearBit :: Natural -> Int -> Natural Source # complementBit :: Natural -> Int -> Natural Source # testBit :: Natural -> Int -> Bool Source # bitSizeMaybe :: Natural -> Maybe Int Source # bitSize :: Natural -> Int Source # isSigned :: Natural -> Bool Source # shiftL :: Natural -> Int -> Natural Source # unsafeShiftL :: Natural -> Int -> Natural Source # shiftR :: Natural -> Int -> Natural Source # unsafeShiftR :: Natural -> Int -> Natural Source # rotateL :: Natural -> Int -> Natural Source # rotateR :: Natural -> Int -> Natural Source # popCount :: Natural -> Int Source #
NFData Natural	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> () Source #
UniformRange Natural
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Natural , Natural ) -> g -> m Natural Source #
HeapWords Natural Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Natural -> Int Source #
Lift Natural
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Natural -> Q Exp Source # liftTyped :: Natural -> Q ( TExp Natural ) Source #
Monad m => ToJSON m Natural Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods toJSON :: Natural -> m JSValue Source #
MonadError SchemaError m => FromJSON m Natural Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods fromJSON :: JSValue -> m Natural Source #

data Maybe a Source #

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

Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Source # (>>) :: Maybe a -> Maybe b -> Maybe b Source # return :: a -> Maybe a Source #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b Source # (<$) :: a -> Maybe b -> Maybe a Source #
MonadFail Maybe	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> Maybe a Source #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a Source # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c Source # (>) :: Maybe a -> Maybe b -> Maybe b Source # (<*) :: Maybe a -> Maybe b -> Maybe a Source #
Foldable Maybe	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m Source # foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m Source # foldr :: (a -> b -> b) -> b -> Maybe a -> b Source # foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source # foldl :: (b -> a -> b) -> b -> Maybe a -> b Source # foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source # foldr1 :: (a -> a -> a) -> Maybe a -> a Source # foldl1 :: (a -> a -> a) -> Maybe a -> a Source # toList :: Maybe a -> [a] Source # null :: Maybe a -> Bool Source # length :: Maybe a -> Int Source # elem :: Eq a => a -> Maybe a -> Bool Source # maximum :: Ord a => Maybe a -> a Source # minimum :: Ord a => Maybe a -> a Source # sum :: Num a => Maybe a -> a Source # product :: Num a => Maybe a -> a Source #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f ( Maybe b) Source # sequenceA :: Applicative f => Maybe (f a) -> f ( Maybe a) Source # mapM :: Monad m => (a -> m b) -> Maybe a -> m ( Maybe b) Source # sequence :: Monad m => Maybe (m a) -> m ( Maybe a) Source #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a Source # (<\|>) :: Maybe a -> Maybe a -> Maybe a Source # some :: Maybe a -> Maybe [a] Source # many :: Maybe a -> Maybe [a] Source #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a Source # mplus :: Maybe a -> Maybe a -> Maybe a Source #
NFData1 Maybe	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Maybe a -> () Source #
Hashable1 Maybe
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Maybe a -> Int Source #
MonadError () Maybe	Since: mtl-2.2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: () -> Maybe a Source # catchError :: Maybe a -> (() -> Maybe a) -> Maybe a Source #
Lift a => Lift ( Maybe a :: Type )
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Maybe a -> Q Exp Source # liftTyped :: Maybe a -> Q ( TExp ( Maybe a)) Source #
Eq a => Eq ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool Source # (/=) :: Maybe a -> Maybe a -> Bool Source #
Ord a => Ord ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering Source # (<) :: Maybe a -> Maybe a -> Bool Source # (<=) :: Maybe a -> Maybe a -> Bool Source # (>) :: Maybe a -> Maybe a -> Bool Source # (>=) :: Maybe a -> Maybe a -> Bool Source # max :: Maybe a -> Maybe a -> Maybe a Source # min :: Maybe a -> Maybe a -> Maybe a Source #
Read a => Read ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS ( Maybe a) Source # readList :: ReadS [ Maybe a] Source # readPrec :: ReadPrec ( Maybe a) Source # readListPrec :: ReadPrec [ Maybe a] Source #
Show a => Show ( Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS Source # show :: Maybe a -> String Source # showList :: [ Maybe a] -> ShowS Source #
Generic ( Maybe a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Maybe a) :: Type -> Type Source # Methods from :: Maybe a -> Rep ( Maybe a) x Source # to :: Rep ( Maybe a) x -> Maybe a Source #
Semigroup a => Semigroup ( Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a Source # sconcat :: NonEmpty ( Maybe a) -> Maybe a Source # stimes :: Integral b => b -> Maybe a -> Maybe a Source #
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 Source # mappend :: Maybe a -> Maybe a -> Maybe a Source # mconcat :: [ Maybe a] -> Maybe a Source #
Hashable a => Hashable ( Maybe a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Maybe a -> Int Source # hash :: Maybe a -> Int Source #
NFData a => NFData ( Maybe a)
Instance details Defined in Control.DeepSeq Methods rnf :: Maybe a -> () Source #
Buildable a => Buildable ( Maybe a)
Instance details Defined in Formatting.Buildable Methods build :: Maybe a -> Builder Source #
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)
HeapWords a => HeapWords ( Maybe a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Maybe a -> Int Source #
Generic1 Maybe	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Maybe :: k -> Type Source # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a Source # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a Source #
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 Rep ( Maybe a)
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)))
type DemoteRep ( Maybe a)
Instance details Defined in GHC.Generics type DemoteRep ( Maybe a) = Maybe (DemoteRep 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)
type Rep1 Maybe
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 ))

data Ordering Source #

Constructors

LT
EQ
GT

Instances

Instances details

Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering Source # maxBound :: Ordering Source #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering Source # pred :: Ordering -> Ordering Source # toEnum :: Int -> Ordering Source # fromEnum :: Ordering -> Int Source # enumFrom :: Ordering -> [ Ordering ] Source # enumFromThen :: Ordering -> Ordering -> [ Ordering ] Source # enumFromTo :: Ordering -> Ordering -> [ Ordering ] Source # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [ Ordering ] Source #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool Source # (/=) :: Ordering -> Ordering -> Bool Source #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering Source # (<) :: Ordering -> Ordering -> Bool Source # (<=) :: Ordering -> Ordering -> Bool Source # (>) :: Ordering -> Ordering -> Bool Source # (>=) :: Ordering -> Ordering -> Bool Source # max :: Ordering -> Ordering -> Ordering Source # min :: Ordering -> Ordering -> Ordering Source #
Read Ordering	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Ordering Source # readList :: ReadS [ Ordering ] Source # readPrec :: ReadPrec Ordering Source # readListPrec :: ReadPrec [ Ordering ] Source #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS Source # show :: Ordering -> String Source # showList :: [ Ordering ] -> ShowS Source #
Ix Ordering	Since: base-2.1
Instance details Defined in GHC.Ix Methods range :: ( Ordering , Ordering ) -> [ Ordering ] Source # index :: ( Ordering , Ordering ) -> Ordering -> Int Source # unsafeIndex :: ( Ordering , Ordering ) -> Ordering -> Int Source # inRange :: ( Ordering , Ordering ) -> Ordering -> Bool Source # rangeSize :: ( Ordering , Ordering ) -> Int Source # unsafeRangeSize :: ( Ordering , Ordering ) -> Int Source #
Generic Ordering	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type Source # Methods from :: Ordering -> Rep Ordering x Source # to :: Rep Ordering x -> Ordering Source #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering Source # sconcat :: NonEmpty Ordering -> Ordering Source # stimes :: Integral b => b -> Ordering -> Ordering Source #
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering Source # mappend :: Ordering -> Ordering -> Ordering Source # mconcat :: [ Ordering ] -> Ordering Source #
Hashable Ordering
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ordering -> Int Source # hash :: Ordering -> Int Source #
NFData Ordering
Instance details Defined in Control.DeepSeq Methods rnf :: Ordering -> () Source #
type Rep Ordering
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 Ratio a Source #

Rational numbers, with numerator and denominator of some Integral type.

Note that Ratio 's instances inherit the deficiencies from the type parameter's. For example, Ratio Natural 's Num instance has similar problems to Natural 's.

Instances

Instances details

NFData1 Ratio	Available on `base >=4.9` Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Ratio a -> () Source #
Integral a => Lift ( Ratio a :: Type )
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Ratio a -> Q Exp Source # liftTyped :: Ratio a -> Q ( TExp ( Ratio a)) Source #
Integral a => Enum ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods succ :: Ratio a -> Ratio a Source # pred :: Ratio a -> Ratio a Source # toEnum :: Int -> Ratio a Source # fromEnum :: Ratio a -> Int Source # enumFrom :: Ratio a -> [ Ratio a] Source # enumFromThen :: Ratio a -> Ratio a -> [ Ratio a] Source # enumFromTo :: Ratio a -> Ratio a -> [ Ratio a] Source # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [ Ratio a] Source #
Eq a => Eq ( Ratio a)	Since: base-2.1
Instance details Defined in GHC.Real Methods (==) :: Ratio a -> Ratio a -> Bool Source # (/=) :: Ratio a -> Ratio a -> Bool Source #
Integral a => Fractional ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (/) :: Ratio a -> Ratio a -> Ratio a Source # recip :: Ratio a -> Ratio a Source # fromRational :: Rational -> Ratio a Source #
Integral a => Num ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (+) :: Ratio a -> Ratio a -> Ratio a Source # (-) :: Ratio a -> Ratio a -> Ratio a Source # (*) :: Ratio a -> Ratio a -> Ratio a Source # negate :: Ratio a -> Ratio a Source # abs :: Ratio a -> Ratio a Source # signum :: Ratio a -> Ratio a Source # fromInteger :: Integer -> Ratio a Source #
Integral a => Ord ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods compare :: Ratio a -> Ratio a -> Ordering Source # (<) :: Ratio a -> Ratio a -> Bool Source # (<=) :: Ratio a -> Ratio a -> Bool Source # (>) :: Ratio a -> Ratio a -> Bool Source # (>=) :: Ratio a -> Ratio a -> Bool Source # max :: Ratio a -> Ratio a -> Ratio a Source # min :: Ratio a -> Ratio a -> Ratio a Source #
( Integral a, Read a) => Read ( Ratio a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS ( Ratio a) Source # readList :: ReadS [ Ratio a] Source # readPrec :: ReadPrec ( Ratio a) Source # readListPrec :: ReadPrec [ Ratio a] Source #
Integral a => Real ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Ratio a -> Rational Source #
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) Source # truncate :: Integral b => Ratio a -> b Source # round :: Integral b => Ratio a -> b Source # ceiling :: Integral b => Ratio a -> b Source # floor :: Integral b => Ratio a -> b Source #
Show a => Show ( Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods showsPrec :: Int -> Ratio a -> ShowS Source # show :: Ratio a -> String Source # showList :: [ Ratio a] -> ShowS Source #
Hashable a => Hashable ( Ratio a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ratio a -> Int Source # hash :: Ratio a -> Int Source #
( Storable a, Integral a) => Storable ( Ratio a)	Since: base-4.8.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: Ratio a -> Int Source # alignment :: Ratio a -> Int Source # peekElemOff :: Ptr ( Ratio a) -> Int -> IO ( Ratio a) Source # pokeElemOff :: Ptr ( Ratio a) -> Int -> Ratio a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Ratio a) Source # pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () Source # peek :: Ptr ( Ratio a) -> IO ( Ratio a) Source # poke :: Ptr ( Ratio a) -> Ratio a -> IO () Source #
NFData a => NFData ( Ratio a)
Instance details Defined in Control.DeepSeq Methods rnf :: Ratio a -> () Source #
( Integral a, Buildable a) => Buildable ( Ratio a)
Instance details Defined in Formatting.Buildable Methods build :: Ratio a -> Builder Source #

type Rational = Ratio Integer Source #

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

data StablePtr a Source #

A stable pointer is a reference to a Haskell expression that is guaranteed not to be affected by garbage collection, i.e., it will neither be deallocated nor will the value of the stable pointer itself change during garbage collection (ordinary references may be relocated during garbage collection). Consequently, stable pointers can be passed to foreign code, which can treat it as an opaque reference to a Haskell value.

A value of type StablePtr a is a stable pointer to a Haskell expression of type a .

Instances

Instances details

IArray UArray ( StablePtr a)
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i ( StablePtr a) -> (i, i) Source # numElements :: Ix i => UArray i ( StablePtr a) -> Int unsafeArray :: Ix i => (i, i) -> [( Int , StablePtr a)] -> UArray i ( StablePtr a) unsafeAt :: Ix i => UArray i ( StablePtr a) -> Int -> StablePtr a unsafeReplace :: Ix i => UArray i ( StablePtr a) -> [( Int , StablePtr a)] -> UArray i ( StablePtr a) unsafeAccum :: Ix i => ( StablePtr a -> e' -> StablePtr a) -> UArray i ( StablePtr a) -> [( Int , e')] -> UArray i ( StablePtr a) unsafeAccumArray :: Ix i => ( StablePtr a -> e' -> StablePtr a) -> StablePtr a -> (i, i) -> [( Int , e')] -> UArray i ( StablePtr a)
Eq ( StablePtr a)	Since: base-2.1
Instance details Defined in GHC.Stable Methods (==) :: StablePtr a -> StablePtr a -> Bool Source # (/=) :: StablePtr a -> StablePtr a -> Bool Source #
Storable ( StablePtr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: StablePtr a -> Int Source # alignment :: StablePtr a -> Int Source # peekElemOff :: Ptr ( StablePtr a) -> Int -> IO ( StablePtr a) Source # pokeElemOff :: Ptr ( StablePtr a) -> Int -> StablePtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( StablePtr a) Source # pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO () Source # peek :: Ptr ( StablePtr a) -> IO ( StablePtr a) Source # poke :: Ptr ( StablePtr a) -> StablePtr a -> IO () Source #
Prim ( StablePtr a)
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: StablePtr a -> Int# Source # alignment# :: StablePtr a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> StablePtr a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, StablePtr a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> StablePtr a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> StablePtr a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> StablePtr a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, StablePtr a #) Source # writeOffAddr# :: Addr# -> Int# -> StablePtr a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> StablePtr a -> State# s -> State# s Source #
MArray ( STUArray s) ( StablePtr a) ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i ( StablePtr a) -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i ( StablePtr a) -> ST s Int newArray :: Ix i => (i, i) -> StablePtr a -> ST s ( STUArray s i ( StablePtr a)) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( StablePtr a)) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( StablePtr a)) unsafeRead :: Ix i => STUArray s i ( StablePtr a) -> Int -> ST s ( StablePtr a) unsafeWrite :: Ix i => STUArray s i ( StablePtr a) -> Int -> StablePtr a -> ST s ()

data IO a Source #

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

Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b Source # (>>) :: IO a -> IO b -> IO b Source # return :: a -> IO a Source #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b Source # (<$) :: a -> IO b -> IO a Source #
MonadFail IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> IO a Source #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a Source # (<>) :: IO (a -> b) -> IO a -> IO b Source # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c Source # (>) :: IO a -> IO b -> IO b Source # (<*) :: IO a -> IO b -> IO a Source #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a Source # (<\|>) :: IO a -> IO a -> IO a Source # some :: IO a -> IO [a] Source # many :: IO a -> IO [a] Source #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a Source # mplus :: IO a -> IO a -> IO a Source #
MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a Source #
PrimMonad IO
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState IO Source # Methods primitive :: ( State# ( PrimState IO ) -> (# State# ( PrimState IO ), a #)) -> IO a Source #
PrimBase IO
Instance details Defined in Control.Monad.Primitive Methods internal :: IO a -> State# ( PrimState IO ) -> (# State# ( PrimState IO ), a #) Source #
Quasi IO
Instance details Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> IO Name Source # qReport :: Bool -> String -> IO () Source # qRecover :: IO a -> IO a -> IO a Source # qLookupName :: Bool -> String -> IO ( Maybe Name ) Source # qReify :: Name -> IO Info Source # qReifyFixity :: Name -> IO ( Maybe Fixity ) Source # qReifyType :: Name -> IO Type Source # qReifyInstances :: Name -> [ Type ] -> IO [ Dec ] Source # qReifyRoles :: Name -> IO [ Role ] Source # qReifyAnnotations :: Data a => AnnLookup -> IO [a] Source # qReifyModule :: Module -> IO ModuleInfo Source # qReifyConStrictness :: Name -> IO [ DecidedStrictness ] Source # qLocation :: IO Loc Source # qRunIO :: IO a -> IO a Source # qAddDependentFile :: FilePath -> IO () Source # qAddTempFile :: String -> IO FilePath Source # qAddTopDecls :: [ Dec ] -> IO () Source # qAddForeignFilePath :: ForeignSrcLang -> String -> IO () Source # qAddModFinalizer :: Q () -> IO () Source # qAddCorePlugin :: String -> IO () Source # qGetQ :: Typeable a => IO ( Maybe a) Source # qPutQ :: Typeable a => a -> IO () Source # qIsExtEnabled :: Extension -> IO Bool Source # qExtsEnabled :: IO [ Extension ] Source #
MonadError IOException IO
Instance details Defined in Control.Monad.Error.Class Methods throwError :: IOException -> IO a Source # catchError :: IO a -> ( IOException -> IO a) -> IO a Source #
MArray IOArray e IO
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => IOArray i e -> IO (i, i) Source # getNumElements :: Ix i => IOArray i e -> IO Int newArray :: Ix i => (i, i) -> e -> IO ( IOArray i e) Source # newArray_ :: Ix i => (i, i) -> IO ( IOArray i e) Source # unsafeNewArray_ :: Ix i => (i, i) -> IO ( IOArray i e) unsafeRead :: Ix i => IOArray i e -> Int -> IO e unsafeWrite :: Ix i => IOArray i e -> Int -> e -> IO ()
Semigroup a => Semigroup ( IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a Source # sconcat :: NonEmpty ( IO a) -> IO a Source # stimes :: Integral b => b -> IO a -> IO a Source #
Monoid a => Monoid ( IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a Source # mappend :: IO a -> IO a -> IO a Source # mconcat :: [ IO a] -> IO a Source #
type PrimState IO
Instance details Defined in Control.Monad.Primitive type PrimState IO = RealWorld

data Word Source #

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

Instances

Instances details

Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word Source # maxBound :: Word Source #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word Source # pred :: Word -> Word Source # toEnum :: Int -> Word Source # fromEnum :: Word -> Int Source # enumFrom :: Word -> [ Word ] Source # enumFromThen :: Word -> Word -> [ Word ] Source # enumFromTo :: Word -> Word -> [ Word ] Source # enumFromThenTo :: Word -> Word -> Word -> [ Word ] Source #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool Source # (/=) :: Word -> Word -> Bool Source #
Integral Word	Since: base-2.1
Instance details Defined in GHC.Real Methods quot :: Word -> Word -> Word Source # rem :: Word -> Word -> Word Source # div :: Word -> Word -> Word Source # mod :: Word -> Word -> Word Source # quotRem :: Word -> Word -> ( Word , Word ) Source # divMod :: Word -> Word -> ( Word , Word ) Source # toInteger :: Word -> Integer Source #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word Source # (-) :: Word -> Word -> Word Source # (*) :: Word -> Word -> Word Source # negate :: Word -> Word Source # abs :: Word -> Word Source # signum :: Word -> Word Source # fromInteger :: Integer -> Word Source #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering Source # (<) :: Word -> Word -> Bool Source # (<=) :: Word -> Word -> Bool Source # (>) :: Word -> Word -> Bool Source # (>=) :: Word -> Word -> Bool Source # max :: Word -> Word -> Word Source # min :: Word -> Word -> Word Source #
Read Word	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word Source # readList :: ReadS [ Word ] Source # readPrec :: ReadPrec Word Source # readListPrec :: ReadPrec [ Word ] Source #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational Source #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS Source # show :: Word -> String Source # showList :: [ Word ] -> ShowS Source #
Ix Word	Since: base-4.6.0.0
Instance details Defined in GHC.Ix Methods range :: ( Word , Word ) -> [ Word ] Source # index :: ( Word , Word ) -> Word -> Int Source # unsafeIndex :: ( Word , Word ) -> Word -> Int Source # inRange :: ( Word , Word ) -> Word -> Bool Source # rangeSize :: ( Word , Word ) -> Int Source # unsafeRangeSize :: ( Word , Word ) -> Int Source #
Hashable Word
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word -> Int Source # hash :: Word -> Int Source #
Storable Word	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word -> Int Source # alignment :: Word -> Int Source # peekElemOff :: Ptr Word -> Int -> IO Word Source # pokeElemOff :: Ptr Word -> Int -> Word -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word Source # pokeByteOff :: Ptr b -> Int -> Word -> IO () Source # peek :: Ptr Word -> IO Word Source # poke :: Ptr Word -> Word -> IO () Source #
Bits Word	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Word -> Word -> Word Source # (.\|.) :: Word -> Word -> Word Source # xor :: Word -> Word -> Word Source # complement :: Word -> Word Source # shift :: Word -> Int -> Word Source # rotate :: Word -> Int -> Word Source # zeroBits :: Word Source # bit :: Int -> Word Source # setBit :: Word -> Int -> Word Source # clearBit :: Word -> Int -> Word Source # complementBit :: Word -> Int -> Word Source # testBit :: Word -> Int -> Bool Source # bitSizeMaybe :: Word -> Maybe Int Source # bitSize :: Word -> Int Source # isSigned :: Word -> Bool Source # shiftL :: Word -> Int -> Word Source # unsafeShiftL :: Word -> Int -> Word Source # shiftR :: Word -> Int -> Word Source # unsafeShiftR :: Word -> Int -> Word Source # rotateL :: Word -> Int -> Word Source # rotateR :: Word -> Int -> Word Source # popCount :: Word -> Int Source #
FiniteBits Word	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Word -> Int Source # countLeadingZeros :: Word -> Int Source # countTrailingZeros :: Word -> Int Source #
NFData Word
Instance details Defined in Control.DeepSeq Methods rnf :: Word -> () Source #
Buildable Word
Instance details Defined in Formatting.Buildable Methods build :: Word -> Builder Source #
Prim Word
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word -> Int# Source # alignment# :: Word -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Word Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Word Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word #) Source # writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s Source #
Uniform Word
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word Source #
UniformRange Word
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Word , Word ) -> g -> m Word Source #
Unbox Word
Instance details Defined in Data.Vector.Unboxed.Base
HeapWords Word Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word -> Int Source #
Lift Word
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word -> Q Exp Source # liftTyped :: Word -> Q ( TExp Word ) Source #
IArray UArray Word
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word -> (i, i) Source # numElements :: Ix i => UArray i Word -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Word )] -> UArray i Word unsafeAt :: Ix i => UArray i Word -> Int -> Word unsafeReplace :: Ix i => UArray i Word -> [( Int , Word )] -> UArray i Word unsafeAccum :: Ix i => ( Word -> e' -> Word ) -> UArray i Word -> [( Int , e')] -> UArray i Word unsafeAccumArray :: Ix i => ( Word -> e' -> Word ) -> Word -> (i, i) -> [( Int , e')] -> UArray i Word
Vector Vector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word -> m ( Vector Word ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word -> m ( Mutable Vector ( PrimState m) Word ) Source # basicLength :: Vector Word -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word Source # basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word -> Vector Word -> m () Source # elemseq :: Vector Word -> Word -> b -> b Source #
MVector MVector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word Source # basicOverlaps :: MVector s Word -> MVector s Word -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m ( MVector ( PrimState m) Word ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word -> Int -> m Word Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word -> Int -> Word -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word -> Word -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word -> MVector ( PrimState m) Word -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word -> MVector ( PrimState m) Word -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word -> Int -> m ( MVector ( PrimState m) Word ) Source #
Generic1 ( URec Word :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Word ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 ( URec Word ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Word ) a -> URec Word a Source #
Foldable ( UWord :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m Source # foldMap :: Monoid m => (a -> m) -> UWord a -> m Source # foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source # foldr :: (a -> b -> b) -> b -> UWord a -> b Source # foldr' :: (a -> b -> b) -> b -> UWord a -> b Source # foldl :: (b -> a -> b) -> b -> UWord a -> b Source # foldl' :: (b -> a -> b) -> b -> UWord a -> b Source # foldr1 :: (a -> a -> a) -> UWord a -> a Source # foldl1 :: (a -> a -> a) -> UWord a -> a Source # toList :: UWord a -> [a] Source # null :: UWord a -> Bool Source # length :: UWord a -> Int Source # elem :: Eq a => a -> UWord a -> Bool Source # maximum :: Ord a => UWord a -> a Source # minimum :: Ord a => UWord a -> a Source # sum :: Num a => UWord a -> a Source # product :: Num a => UWord a -> a Source #
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) Source # sequenceA :: Applicative f => UWord (f a) -> f ( UWord a) Source # mapM :: Monad m => (a -> m b) -> UWord a -> m ( UWord b) Source # sequence :: Monad m => UWord (m a) -> m ( UWord a) Source #
MArray ( STUArray s) Word ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word -> ST s Int newArray :: Ix i => (i, i) -> Word -> ST s ( STUArray s i Word ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word ) unsafeRead :: Ix i => STUArray s i Word -> Int -> ST s Word unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> ST s ()
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 Source # (<$) :: a -> URec Word b -> URec Word a Source #
Eq ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool Source # (/=) :: URec Word p -> URec Word p -> Bool Source #
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 Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source # max :: URec Word p -> URec Word p -> URec Word p Source # min :: URec Word p -> URec Word p -> URec Word p Source #
Show ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS Source # show :: URec Word p -> String Source # showList :: [ URec Word p] -> ShowS Source #
Generic ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep ( URec Word p) x Source # to :: Rep ( URec Word p) x -> URec Word p Source #
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 )
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)
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 Word8 Source #

8-bit unsigned integer type

Instances

Instances details

Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 Source # maxBound :: Word8 Source #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 Source # pred :: Word8 -> Word8 Source # toEnum :: Int -> Word8 Source # fromEnum :: Word8 -> Int Source # enumFrom :: Word8 -> [ Word8 ] Source # enumFromThen :: Word8 -> Word8 -> [ Word8 ] Source # enumFromTo :: Word8 -> Word8 -> [ Word8 ] Source # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [ Word8 ] Source #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool Source # (/=) :: Word8 -> Word8 -> Bool Source #
Integral Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word8 -> Word8 -> Word8 Source # rem :: Word8 -> Word8 -> Word8 Source # div :: Word8 -> Word8 -> Word8 Source # mod :: Word8 -> Word8 -> Word8 Source # quotRem :: Word8 -> Word8 -> ( Word8 , Word8 ) Source # divMod :: Word8 -> Word8 -> ( Word8 , Word8 ) Source # toInteger :: Word8 -> Integer Source #
Num Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word8 -> Word8 -> Word8 Source # (-) :: Word8 -> Word8 -> Word8 Source # (*) :: Word8 -> Word8 -> Word8 Source # negate :: Word8 -> Word8 Source # abs :: Word8 -> Word8 Source # signum :: Word8 -> Word8 Source # fromInteger :: Integer -> Word8 Source #
Ord Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word8 -> Word8 -> Ordering Source # (<) :: Word8 -> Word8 -> Bool Source # (<=) :: Word8 -> Word8 -> Bool Source # (>) :: Word8 -> Word8 -> Bool Source # (>=) :: Word8 -> Word8 -> Bool Source # max :: Word8 -> Word8 -> Word8 Source # min :: Word8 -> Word8 -> Word8 Source #
Read Word8	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word8 Source # readList :: ReadS [ Word8 ] Source # readPrec :: ReadPrec Word8 Source # readListPrec :: ReadPrec [ Word8 ] Source #
Real Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word8 -> Rational Source #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS Source # show :: Word8 -> String Source # showList :: [ Word8 ] -> ShowS Source #
Ix Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: ( Word8 , Word8 ) -> [ Word8 ] Source # index :: ( Word8 , Word8 ) -> Word8 -> Int Source # unsafeIndex :: ( Word8 , Word8 ) -> Word8 -> Int Source # inRange :: ( Word8 , Word8 ) -> Word8 -> Bool Source # rangeSize :: ( Word8 , Word8 ) -> Int Source # unsafeRangeSize :: ( Word8 , Word8 ) -> Int Source #
Hashable Word8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word8 -> Int Source # hash :: Word8 -> Int Source #
Storable Word8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word8 -> Int Source # alignment :: Word8 -> Int Source # peekElemOff :: Ptr Word8 -> Int -> IO Word8 Source # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word8 Source # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () Source # peek :: Ptr Word8 -> IO Word8 Source # poke :: Ptr Word8 -> Word8 -> IO () Source #
Bits Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word8 -> Word8 -> Word8 Source # (.\|.) :: Word8 -> Word8 -> Word8 Source # xor :: Word8 -> Word8 -> Word8 Source # complement :: Word8 -> Word8 Source # shift :: Word8 -> Int -> Word8 Source # rotate :: Word8 -> Int -> Word8 Source # zeroBits :: Word8 Source # bit :: Int -> Word8 Source # setBit :: Word8 -> Int -> Word8 Source # clearBit :: Word8 -> Int -> Word8 Source # complementBit :: Word8 -> Int -> Word8 Source # testBit :: Word8 -> Int -> Bool Source # bitSizeMaybe :: Word8 -> Maybe Int Source # bitSize :: Word8 -> Int Source # isSigned :: Word8 -> Bool Source # shiftL :: Word8 -> Int -> Word8 Source # unsafeShiftL :: Word8 -> Int -> Word8 Source # shiftR :: Word8 -> Int -> Word8 Source # unsafeShiftR :: Word8 -> Int -> Word8 Source # rotateL :: Word8 -> Int -> Word8 Source # rotateR :: Word8 -> Int -> Word8 Source # popCount :: Word8 -> Int Source #
FiniteBits Word8	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word8 -> Int Source # countLeadingZeros :: Word8 -> Int Source # countTrailingZeros :: Word8 -> Int Source #
NFData Word8
Instance details Defined in Control.DeepSeq Methods rnf :: Word8 -> () Source #
Buildable Word8
Instance details Defined in Formatting.Buildable Methods build :: Word8 -> Builder Source #
Prim Word8
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word8 -> Int# Source # alignment# :: Word8 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Word8 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word8 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Word8 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word8 #) Source # writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s Source #
Uniform Word8
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word8 Source #
UniformRange Word8
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Word8 , Word8 ) -> g -> m Word8 Source #
ByteSource Word8
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word8 g -> Word8 -> g
Unbox Word8
Instance details Defined in Data.Vector.Unboxed.Base
HeapWords Word8 Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word8 -> Int Source #
Lift Word8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word8 -> Q Exp Source # liftTyped :: Word8 -> Q ( TExp Word8 ) Source #
IArray UArray Word8
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word8 -> (i, i) Source # numElements :: Ix i => UArray i Word8 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Word8 )] -> UArray i Word8 unsafeAt :: Ix i => UArray i Word8 -> Int -> Word8 unsafeReplace :: Ix i => UArray i Word8 -> [( Int , Word8 )] -> UArray i Word8 unsafeAccum :: Ix i => ( Word8 -> e' -> Word8 ) -> UArray i Word8 -> [( Int , e')] -> UArray i Word8 unsafeAccumArray :: Ix i => ( Word8 -> e' -> Word8 ) -> Word8 -> (i, i) -> [( Int , e')] -> UArray i Word8
Vector Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word8 -> m ( Vector Word8 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m ( Mutable Vector ( PrimState m) Word8 ) Source # basicLength :: Vector Word8 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 Source # basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word8 -> Vector Word8 -> m () Source # elemseq :: Vector Word8 -> Word8 -> b -> b Source #
MVector MVector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word8 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 Source # basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word8 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word8 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m ( MVector ( PrimState m) Word8 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word8 -> Int -> m Word8 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word8 -> Int -> Word8 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word8 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word8 -> Word8 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word8 -> MVector ( PrimState m) Word8 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word8 -> MVector ( PrimState m) Word8 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word8 -> Int -> m ( MVector ( PrimState m) Word8 ) Source #
MArray ( STUArray s) Word8 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word8 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word8 -> ST s Int newArray :: Ix i => (i, i) -> Word8 -> ST s ( STUArray s i Word8 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word8 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word8 ) unsafeRead :: Ix i => STUArray s i Word8 -> Int -> ST s Word8 unsafeWrite :: Ix i => STUArray s i Word8 -> Int -> Word8 -> ST s ()
newtype Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word8 = V_Word8 ( Vector Word8 )
type ByteSink Word8 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word8 g = Takes1Byte g
newtype MVector s Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word8 = MV_Word8 ( MVector s Word8 )

data Word16 Source #

16-bit unsigned integer type

Instances

Instances details

Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 Source # maxBound :: Word16 Source #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 Source # pred :: Word16 -> Word16 Source # toEnum :: Int -> Word16 Source # fromEnum :: Word16 -> Int Source # enumFrom :: Word16 -> [ Word16 ] Source # enumFromThen :: Word16 -> Word16 -> [ Word16 ] Source # enumFromTo :: Word16 -> Word16 -> [ Word16 ] Source # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [ Word16 ] Source #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool Source # (/=) :: Word16 -> Word16 -> Bool Source #
Integral Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word16 -> Word16 -> Word16 Source # rem :: Word16 -> Word16 -> Word16 Source # div :: Word16 -> Word16 -> Word16 Source # mod :: Word16 -> Word16 -> Word16 Source # quotRem :: Word16 -> Word16 -> ( Word16 , Word16 ) Source # divMod :: Word16 -> Word16 -> ( Word16 , Word16 ) Source # toInteger :: Word16 -> Integer Source #
Num Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word16 -> Word16 -> Word16 Source # (-) :: Word16 -> Word16 -> Word16 Source # (*) :: Word16 -> Word16 -> Word16 Source # negate :: Word16 -> Word16 Source # abs :: Word16 -> Word16 Source # signum :: Word16 -> Word16 Source # fromInteger :: Integer -> Word16 Source #
Ord Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word16 -> Word16 -> Ordering Source # (<) :: Word16 -> Word16 -> Bool Source # (<=) :: Word16 -> Word16 -> Bool Source # (>) :: Word16 -> Word16 -> Bool Source # (>=) :: Word16 -> Word16 -> Bool Source # max :: Word16 -> Word16 -> Word16 Source # min :: Word16 -> Word16 -> Word16 Source #
Read Word16	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word16 Source # readList :: ReadS [ Word16 ] Source # readPrec :: ReadPrec Word16 Source # readListPrec :: ReadPrec [ Word16 ] Source #
Real Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word16 -> Rational Source #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS Source # show :: Word16 -> String Source # showList :: [ Word16 ] -> ShowS Source #
Ix Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: ( Word16 , Word16 ) -> [ Word16 ] Source # index :: ( Word16 , Word16 ) -> Word16 -> Int Source # unsafeIndex :: ( Word16 , Word16 ) -> Word16 -> Int Source # inRange :: ( Word16 , Word16 ) -> Word16 -> Bool Source # rangeSize :: ( Word16 , Word16 ) -> Int Source # unsafeRangeSize :: ( Word16 , Word16 ) -> Int Source #
Hashable Word16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word16 -> Int Source # hash :: Word16 -> Int Source #
Storable Word16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word16 -> Int Source # alignment :: Word16 -> Int Source # peekElemOff :: Ptr Word16 -> Int -> IO Word16 Source # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word16 Source # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () Source # peek :: Ptr Word16 -> IO Word16 Source # poke :: Ptr Word16 -> Word16 -> IO () Source #
Bits Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word16 -> Word16 -> Word16 Source # (.\|.) :: Word16 -> Word16 -> Word16 Source # xor :: Word16 -> Word16 -> Word16 Source # complement :: Word16 -> Word16 Source # shift :: Word16 -> Int -> Word16 Source # rotate :: Word16 -> Int -> Word16 Source # zeroBits :: Word16 Source # bit :: Int -> Word16 Source # setBit :: Word16 -> Int -> Word16 Source # clearBit :: Word16 -> Int -> Word16 Source # complementBit :: Word16 -> Int -> Word16 Source # testBit :: Word16 -> Int -> Bool Source # bitSizeMaybe :: Word16 -> Maybe Int Source # bitSize :: Word16 -> Int Source # isSigned :: Word16 -> Bool Source # shiftL :: Word16 -> Int -> Word16 Source # unsafeShiftL :: Word16 -> Int -> Word16 Source # shiftR :: Word16 -> Int -> Word16 Source # unsafeShiftR :: Word16 -> Int -> Word16 Source # rotateL :: Word16 -> Int -> Word16 Source # rotateR :: Word16 -> Int -> Word16 Source # popCount :: Word16 -> Int Source #
FiniteBits Word16	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word16 -> Int Source # countLeadingZeros :: Word16 -> Int Source # countTrailingZeros :: Word16 -> Int Source #
NFData Word16
Instance details Defined in Control.DeepSeq Methods rnf :: Word16 -> () Source #
Buildable Word16
Instance details Defined in Formatting.Buildable Methods build :: Word16 -> Builder Source #
Prim Word16
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word16 -> Int# Source # alignment# :: Word16 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Word16 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Word16 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word16 #) Source # writeOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Word16 -> State# s -> State# s Source #
Uniform Word16
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word16 Source #
UniformRange Word16
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Word16 , Word16 ) -> g -> m Word16 Source #
ByteSource Word16
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word16 g -> Word16 -> g
Unbox Word16
Instance details Defined in Data.Vector.Unboxed.Base
Lift Word16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word16 -> Q Exp Source # liftTyped :: Word16 -> Q ( TExp Word16 ) Source #
IArray UArray Word16
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word16 -> (i, i) Source # numElements :: Ix i => UArray i Word16 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Word16 )] -> UArray i Word16 unsafeAt :: Ix i => UArray i Word16 -> Int -> Word16 unsafeReplace :: Ix i => UArray i Word16 -> [( Int , Word16 )] -> UArray i Word16 unsafeAccum :: Ix i => ( Word16 -> e' -> Word16 ) -> UArray i Word16 -> [( Int , e')] -> UArray i Word16 unsafeAccumArray :: Ix i => ( Word16 -> e' -> Word16 ) -> Word16 -> (i, i) -> [( Int , e')] -> UArray i Word16
Monad m => ToJSON m Word16 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods toJSON :: Word16 -> m JSValue Source #
ReportSchemaErrors m => FromJSON m Word16 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods fromJSON :: JSValue -> m Word16 Source #
Vector Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word16 -> m ( Vector Word16 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m ( Mutable Vector ( PrimState m) Word16 ) Source # basicLength :: Vector Word16 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 Source # basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word16 -> Vector Word16 -> m () Source # elemseq :: Vector Word16 -> Word16 -> b -> b Source #
MVector MVector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word16 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 Source # basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word16 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word16 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m ( MVector ( PrimState m) Word16 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word16 -> Int -> m Word16 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word16 -> Int -> Word16 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word16 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word16 -> Word16 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word16 -> MVector ( PrimState m) Word16 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word16 -> MVector ( PrimState m) Word16 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word16 -> Int -> m ( MVector ( PrimState m) Word16 ) Source #
MArray ( STUArray s) Word16 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word16 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word16 -> ST s Int newArray :: Ix i => (i, i) -> Word16 -> ST s ( STUArray s i Word16 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word16 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word16 ) unsafeRead :: Ix i => STUArray s i Word16 -> Int -> ST s Word16 unsafeWrite :: Ix i => STUArray s i Word16 -> Int -> Word16 -> ST s ()
newtype Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word16 = V_Word16 ( Vector Word16 )
type ByteSink Word16 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word16 g = Takes2Bytes g
newtype MVector s Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word16 = MV_Word16 ( MVector s Word16 )

data Word32 Source #

32-bit unsigned integer type

Instances

Instances details

Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 Source # maxBound :: Word32 Source #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 Source # pred :: Word32 -> Word32 Source # toEnum :: Int -> Word32 Source # fromEnum :: Word32 -> Int Source # enumFrom :: Word32 -> [ Word32 ] Source # enumFromThen :: Word32 -> Word32 -> [ Word32 ] Source # enumFromTo :: Word32 -> Word32 -> [ Word32 ] Source # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [ Word32 ] Source #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool Source # (/=) :: Word32 -> Word32 -> Bool Source #
Integral Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word32 -> Word32 -> Word32 Source # rem :: Word32 -> Word32 -> Word32 Source # div :: Word32 -> Word32 -> Word32 Source # mod :: Word32 -> Word32 -> Word32 Source # quotRem :: Word32 -> Word32 -> ( Word32 , Word32 ) Source # divMod :: Word32 -> Word32 -> ( Word32 , Word32 ) Source # toInteger :: Word32 -> Integer Source #
Num Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word32 -> Word32 -> Word32 Source # (-) :: Word32 -> Word32 -> Word32 Source # (*) :: Word32 -> Word32 -> Word32 Source # negate :: Word32 -> Word32 Source # abs :: Word32 -> Word32 Source # signum :: Word32 -> Word32 Source # fromInteger :: Integer -> Word32 Source #
Ord Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word32 -> Word32 -> Ordering Source # (<) :: Word32 -> Word32 -> Bool Source # (<=) :: Word32 -> Word32 -> Bool Source # (>) :: Word32 -> Word32 -> Bool Source # (>=) :: Word32 -> Word32 -> Bool Source # max :: Word32 -> Word32 -> Word32 Source # min :: Word32 -> Word32 -> Word32 Source #
Read Word32	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word32 Source # readList :: ReadS [ Word32 ] Source # readPrec :: ReadPrec Word32 Source # readListPrec :: ReadPrec [ Word32 ] Source #
Real Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word32 -> Rational Source #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS Source # show :: Word32 -> String Source # showList :: [ Word32 ] -> ShowS Source #
Ix Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: ( Word32 , Word32 ) -> [ Word32 ] Source # index :: ( Word32 , Word32 ) -> Word32 -> Int Source # unsafeIndex :: ( Word32 , Word32 ) -> Word32 -> Int Source # inRange :: ( Word32 , Word32 ) -> Word32 -> Bool Source # rangeSize :: ( Word32 , Word32 ) -> Int Source # unsafeRangeSize :: ( Word32 , Word32 ) -> Int Source #
Hashable Word32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word32 -> Int Source # hash :: Word32 -> Int Source #
Storable Word32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word32 -> Int Source # alignment :: Word32 -> Int Source # peekElemOff :: Ptr Word32 -> Int -> IO Word32 Source # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word32 Source # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () Source # peek :: Ptr Word32 -> IO Word32 Source # poke :: Ptr Word32 -> Word32 -> IO () Source #
Bits Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word32 -> Word32 -> Word32 Source # (.\|.) :: Word32 -> Word32 -> Word32 Source # xor :: Word32 -> Word32 -> Word32 Source # complement :: Word32 -> Word32 Source # shift :: Word32 -> Int -> Word32 Source # rotate :: Word32 -> Int -> Word32 Source # zeroBits :: Word32 Source # bit :: Int -> Word32 Source # setBit :: Word32 -> Int -> Word32 Source # clearBit :: Word32 -> Int -> Word32 Source # complementBit :: Word32 -> Int -> Word32 Source # testBit :: Word32 -> Int -> Bool Source # bitSizeMaybe :: Word32 -> Maybe Int Source # bitSize :: Word32 -> Int Source # isSigned :: Word32 -> Bool Source # shiftL :: Word32 -> Int -> Word32 Source # unsafeShiftL :: Word32 -> Int -> Word32 Source # shiftR :: Word32 -> Int -> Word32 Source # unsafeShiftR :: Word32 -> Int -> Word32 Source # rotateL :: Word32 -> Int -> Word32 Source # rotateR :: Word32 -> Int -> Word32 Source # popCount :: Word32 -> Int Source #
FiniteBits Word32	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word32 -> Int Source # countLeadingZeros :: Word32 -> Int Source # countTrailingZeros :: Word32 -> Int Source #
NFData Word32
Instance details Defined in Control.DeepSeq Methods rnf :: Word32 -> () Source #
Buildable Word32
Instance details Defined in Formatting.Buildable Methods build :: Word32 -> Builder Source #
Prim Word32
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word32 -> Int# Source # alignment# :: Word32 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Word32 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Word32 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word32 #) Source # writeOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Word32 -> State# s -> State# s Source #
Uniform Word32
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word32 Source #
UniformRange Word32
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Word32 , Word32 ) -> g -> m Word32 Source #
ByteSource Word32
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word32 g -> Word32 -> g
Unbox Word32
Instance details Defined in Data.Vector.Unboxed.Base
HeapWords Word32 Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word32 -> Int Source #
Lift Word32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word32 -> Q Exp Source # liftTyped :: Word32 -> Q ( TExp Word32 ) Source #
IArray UArray Word32
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word32 -> (i, i) Source # numElements :: Ix i => UArray i Word32 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Word32 )] -> UArray i Word32 unsafeAt :: Ix i => UArray i Word32 -> Int -> Word32 unsafeReplace :: Ix i => UArray i Word32 -> [( Int , Word32 )] -> UArray i Word32 unsafeAccum :: Ix i => ( Word32 -> e' -> Word32 ) -> UArray i Word32 -> [( Int , e')] -> UArray i Word32 unsafeAccumArray :: Ix i => ( Word32 -> e' -> Word32 ) -> Word32 -> (i, i) -> [( Int , e')] -> UArray i Word32
Monad m => ToJSON m Word32 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods toJSON :: Word32 -> m JSValue Source #
ReportSchemaErrors m => FromJSON m Word32 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods fromJSON :: JSValue -> m Word32 Source #
Vector Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word32 -> m ( Vector Word32 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m ( Mutable Vector ( PrimState m) Word32 ) Source # basicLength :: Vector Word32 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 Source # basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word32 -> Vector Word32 -> m () Source # elemseq :: Vector Word32 -> Word32 -> b -> b Source #
MVector MVector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word32 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 Source # basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word32 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word32 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m ( MVector ( PrimState m) Word32 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word32 -> Int -> m Word32 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word32 -> Int -> Word32 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word32 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word32 -> Word32 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word32 -> MVector ( PrimState m) Word32 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word32 -> MVector ( PrimState m) Word32 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word32 -> Int -> m ( MVector ( PrimState m) Word32 ) Source #
MArray ( STUArray s) Word32 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word32 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word32 -> ST s Int newArray :: Ix i => (i, i) -> Word32 -> ST s ( STUArray s i Word32 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word32 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word32 ) unsafeRead :: Ix i => STUArray s i Word32 -> Int -> ST s Word32 unsafeWrite :: Ix i => STUArray s i Word32 -> Int -> Word32 -> ST s ()
newtype Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word32 = V_Word32 ( Vector Word32 )
type ByteSink Word32 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word32 g = Takes4Bytes g
newtype MVector s Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word32 = MV_Word32 ( MVector s Word32 )

data Word64 Source #

64-bit unsigned integer type

Instances

Instances details

Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 Source # maxBound :: Word64 Source #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 Source # pred :: Word64 -> Word64 Source # toEnum :: Int -> Word64 Source # fromEnum :: Word64 -> Int Source # enumFrom :: Word64 -> [ Word64 ] Source # enumFromThen :: Word64 -> Word64 -> [ Word64 ] Source # enumFromTo :: Word64 -> Word64 -> [ Word64 ] Source # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [ Word64 ] Source #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool Source # (/=) :: Word64 -> Word64 -> Bool Source #
Integral Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word64 -> Word64 -> Word64 Source # rem :: Word64 -> Word64 -> Word64 Source # div :: Word64 -> Word64 -> Word64 Source # mod :: Word64 -> Word64 -> Word64 Source # quotRem :: Word64 -> Word64 -> ( Word64 , Word64 ) Source # divMod :: Word64 -> Word64 -> ( Word64 , Word64 ) Source # toInteger :: Word64 -> Integer Source #
Num Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word64 -> Word64 -> Word64 Source # (-) :: Word64 -> Word64 -> Word64 Source # (*) :: Word64 -> Word64 -> Word64 Source # negate :: Word64 -> Word64 Source # abs :: Word64 -> Word64 Source # signum :: Word64 -> Word64 Source # fromInteger :: Integer -> Word64 Source #
Ord Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word64 -> Word64 -> Ordering Source # (<) :: Word64 -> Word64 -> Bool Source # (<=) :: Word64 -> Word64 -> Bool Source # (>) :: Word64 -> Word64 -> Bool Source # (>=) :: Word64 -> Word64 -> Bool Source # max :: Word64 -> Word64 -> Word64 Source # min :: Word64 -> Word64 -> Word64 Source #
Read Word64	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word64 Source # readList :: ReadS [ Word64 ] Source # readPrec :: ReadPrec Word64 Source # readListPrec :: ReadPrec [ Word64 ] Source #
Real Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word64 -> Rational Source #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS Source # show :: Word64 -> String Source # showList :: [ Word64 ] -> ShowS Source #
Ix Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: ( Word64 , Word64 ) -> [ Word64 ] Source # index :: ( Word64 , Word64 ) -> Word64 -> Int Source # unsafeIndex :: ( Word64 , Word64 ) -> Word64 -> Int Source # inRange :: ( Word64 , Word64 ) -> Word64 -> Bool Source # rangeSize :: ( Word64 , Word64 ) -> Int Source # unsafeRangeSize :: ( Word64 , Word64 ) -> Int Source #
Hashable Word64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word64 -> Int Source # hash :: Word64 -> Int Source #
Storable Word64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word64 -> Int Source # alignment :: Word64 -> Int Source # peekElemOff :: Ptr Word64 -> Int -> IO Word64 Source # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word64 Source # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () Source # peek :: Ptr Word64 -> IO Word64 Source # poke :: Ptr Word64 -> Word64 -> IO () Source #
Bits Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word64 -> Word64 -> Word64 Source # (.\|.) :: Word64 -> Word64 -> Word64 Source # xor :: Word64 -> Word64 -> Word64 Source # complement :: Word64 -> Word64 Source # shift :: Word64 -> Int -> Word64 Source # rotate :: Word64 -> Int -> Word64 Source # zeroBits :: Word64 Source # bit :: Int -> Word64 Source # setBit :: Word64 -> Int -> Word64 Source # clearBit :: Word64 -> Int -> Word64 Source # complementBit :: Word64 -> Int -> Word64 Source # testBit :: Word64 -> Int -> Bool Source # bitSizeMaybe :: Word64 -> Maybe Int Source # bitSize :: Word64 -> Int Source # isSigned :: Word64 -> Bool Source # shiftL :: Word64 -> Int -> Word64 Source # unsafeShiftL :: Word64 -> Int -> Word64 Source # shiftR :: Word64 -> Int -> Word64 Source # unsafeShiftR :: Word64 -> Int -> Word64 Source # rotateL :: Word64 -> Int -> Word64 Source # rotateR :: Word64 -> Int -> Word64 Source # popCount :: Word64 -> Int Source #
FiniteBits Word64	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word64 -> Int Source # countLeadingZeros :: Word64 -> Int Source # countTrailingZeros :: Word64 -> Int Source #
NFData Word64
Instance details Defined in Control.DeepSeq Methods rnf :: Word64 -> () Source #
Buildable Word64
Instance details Defined in Formatting.Buildable Methods build :: Word64 -> Builder Source #
Prim Word64
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word64 -> Int# Source # alignment# :: Word64 -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Word64 Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64 #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Word64 Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word64 #) Source # writeOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Word64 -> State# s -> State# s Source #
Uniform Word64
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word64 Source #
UniformRange Word64
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ( Word64 , Word64 ) -> g -> m Word64 Source #
ByteSource Word64
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word64 g -> Word64 -> g
Unbox Word64
Instance details Defined in Data.Vector.Unboxed.Base
HeapWords Word64 Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Word64 -> Int Source #
Lift Word64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word64 -> Q Exp Source # liftTyped :: Word64 -> Q ( TExp Word64 ) Source #
IArray UArray Word64
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word64 -> (i, i) Source # numElements :: Ix i => UArray i Word64 -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Word64 )] -> UArray i Word64 unsafeAt :: Ix i => UArray i Word64 -> Int -> Word64 unsafeReplace :: Ix i => UArray i Word64 -> [( Int , Word64 )] -> UArray i Word64 unsafeAccum :: Ix i => ( Word64 -> e' -> Word64 ) -> UArray i Word64 -> [( Int , e')] -> UArray i Word64 unsafeAccumArray :: Ix i => ( Word64 -> e' -> Word64 ) -> Word64 -> (i, i) -> [( Int , e')] -> UArray i Word64
Monad m => ToJSON m Word64 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods toJSON :: Word64 -> m JSValue Source #
ReportSchemaErrors m => FromJSON m Word64 Source #
Instance details Defined in Cardano.Prelude.Json.Canonical Methods fromJSON :: JSValue -> m Word64 Source #
Vector Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word64 -> m ( Vector Word64 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m ( Mutable Vector ( PrimState m) Word64 ) Source # basicLength :: Vector Word64 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 Source # basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word64 -> Vector Word64 -> m () Source # elemseq :: Vector Word64 -> Word64 -> b -> b Source #
MVector MVector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word64 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 Source # basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word64 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word64 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m ( MVector ( PrimState m) Word64 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word64 -> Int -> m Word64 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word64 -> Int -> Word64 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word64 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word64 -> Word64 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word64 -> MVector ( PrimState m) Word64 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word64 -> MVector ( PrimState m) Word64 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word64 -> Int -> m ( MVector ( PrimState m) Word64 ) Source #
MArray ( STUArray s) Word64 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word64 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word64 -> ST s Int newArray :: Ix i => (i, i) -> Word64 -> ST s ( STUArray s i Word64 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word64 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word64 ) unsafeRead :: Ix i => STUArray s i Word64 -> Int -> ST s Word64 unsafeWrite :: Ix i => STUArray s i Word64 -> Int -> Word64 -> ST s ()
newtype Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word64 = V_Word64 ( Vector Word64 )
type ByteSink Word64 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word64 g = Takes8Bytes g
newtype MVector s Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word64 = MV_Word64 ( MVector s Word64 )

data Ptr a Source #

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a .

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct .

Instances

Instances details

NFData1 Ptr	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Ptr a -> () Source #
IArray UArray ( Ptr a)
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i ( Ptr a) -> (i, i) Source # numElements :: Ix i => UArray i ( Ptr a) -> Int unsafeArray :: Ix i => (i, i) -> [( Int , Ptr a)] -> UArray i ( Ptr a) unsafeAt :: Ix i => UArray i ( Ptr a) -> Int -> Ptr a unsafeReplace :: Ix i => UArray i ( Ptr a) -> [( Int , Ptr a)] -> UArray i ( Ptr a) unsafeAccum :: Ix i => ( Ptr a -> e' -> Ptr a) -> UArray i ( Ptr a) -> [( Int , e')] -> UArray i ( Ptr a) unsafeAccumArray :: Ix i => ( Ptr a -> e' -> Ptr a) -> Ptr a -> (i, i) -> [( Int , e')] -> UArray i ( Ptr a)
Generic1 ( URec ( Ptr ()) :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec ( Ptr ())) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec ( Ptr ()) a -> Rep1 ( URec ( Ptr ())) a Source # to1 :: forall (a :: k0). Rep1 ( URec ( Ptr ())) a -> URec ( Ptr ()) a Source #
Eq ( Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods (==) :: Ptr a -> Ptr a -> Bool Source # (/=) :: Ptr a -> Ptr a -> Bool Source #
Ord ( Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods compare :: Ptr a -> Ptr a -> Ordering Source # (<) :: Ptr a -> Ptr a -> Bool Source # (<=) :: Ptr a -> Ptr a -> Bool Source # (>) :: Ptr a -> Ptr a -> Bool Source # (>=) :: Ptr a -> Ptr a -> Bool Source # max :: Ptr a -> Ptr a -> Ptr a Source # min :: Ptr a -> Ptr a -> Ptr a Source #
Show ( Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> Ptr a -> ShowS Source # show :: Ptr a -> String Source # showList :: [ Ptr a] -> ShowS Source #
Foldable ( UAddr :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m Source # foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source # foldr :: (a -> b -> b) -> b -> UAddr a -> b Source # foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source # foldl :: (b -> a -> b) -> b -> UAddr a -> b Source # foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source # foldr1 :: (a -> a -> a) -> UAddr a -> a Source # foldl1 :: (a -> a -> a) -> UAddr a -> a Source # toList :: UAddr a -> [a] Source # null :: UAddr a -> Bool Source # length :: UAddr a -> Int Source # elem :: Eq a => a -> UAddr a -> Bool Source # maximum :: Ord a => UAddr a -> a Source # minimum :: Ord a => UAddr a -> a Source # sum :: Num a => UAddr a -> a Source # product :: Num a => UAddr a -> a Source #
Traversable ( UAddr :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f ( UAddr b) Source # sequenceA :: Applicative f => UAddr (f a) -> f ( UAddr a) Source # mapM :: Monad m => (a -> m b) -> UAddr a -> m ( UAddr b) Source # sequence :: Monad m => UAddr (m a) -> m ( UAddr a) Source #
Hashable ( Ptr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ptr a -> Int Source # hash :: Ptr a -> Int Source #
Storable ( Ptr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Ptr a -> Int Source # alignment :: Ptr a -> Int Source # peekElemOff :: Ptr ( Ptr a) -> Int -> IO ( Ptr a) Source # pokeElemOff :: Ptr ( Ptr a) -> Int -> Ptr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Ptr a) Source # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () Source # peek :: Ptr ( Ptr a) -> IO ( Ptr a) Source # poke :: Ptr ( Ptr a) -> Ptr a -> IO () Source #
NFData ( Ptr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Ptr a -> () Source #
Buildable ( Ptr a)
Instance details Defined in Formatting.Buildable Methods build :: Ptr a -> Builder Source #
Prim ( Ptr a)
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Ptr a -> Int# Source # alignment# :: Ptr a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Ptr a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Ptr a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Ptr a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Ptr a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Ptr a #) Source # writeOffAddr# :: Addr# -> Int# -> Ptr a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Ptr a -> State# s -> State# s Source #
MArray ( STUArray s) ( Ptr a) ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i ( Ptr a) -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i ( Ptr a) -> ST s Int newArray :: Ix i => (i, i) -> Ptr a -> ST s ( STUArray s i ( Ptr a)) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( Ptr a)) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( Ptr a)) unsafeRead :: Ix i => STUArray s i ( Ptr a) -> Int -> ST s ( Ptr a) unsafeWrite :: Ix i => STUArray s i ( Ptr a) -> Int -> Ptr a -> ST s ()
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 Source # (<$) :: a -> URec ( Ptr ()) b -> URec ( Ptr ()) a Source #
Eq ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (/=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source #
Ord ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Ordering Source # (<) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (<=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # max :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source # min :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source #
Generic ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec ( Ptr ()) p) :: Type -> Type Source # Methods from :: URec ( Ptr ()) p -> Rep ( URec ( Ptr ()) p) x Source # to :: Rep ( URec ( Ptr ()) p) x -> URec ( Ptr ()) p Source #
data URec ( Ptr ()) (p :: k)	Used for marking occurrences of `Addr#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec ( Ptr ()) (p :: k) = UAddr { uAddr# :: Addr# }
type Rep1 ( URec ( Ptr ()) :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 ( URec ( Ptr ()) :: k -> Type ) = D1 (' MetaData "URec" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "UAddr" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "uAddr#") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( UAddr :: k -> Type )))
type Rep ( URec ( Ptr ()) p)
Instance details Defined in GHC.Generics type Rep ( URec ( Ptr ()) p) = D1 (' MetaData "URec" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "UAddr" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "uAddr#") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( UAddr :: Type -> Type )))

data FunPtr a Source #

A value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type , a function type with zero or more arguments where

the argument types are marshallable foreign types , i.e. Char , Int , Double , Float , Bool , Int8 , Int16 , Int32 , Int64 , Word8 , Word16 , Word32 , Word64 , Ptr a , FunPtr a , StablePtr a or a renaming of any of these using newtype .
the return type is either a marshallable foreign type or has the form IO t where t is a marshallable foreign type or () .

A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

foreign import ccall "stdlib.h &free"
  p_free :: FunPtr (Ptr a -> IO ())

or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example:

type Compare = Int -> Int -> Bool
foreign import ccall "wrapper"
  mkCompare :: Compare -> IO (FunPtr Compare)

Calls to wrapper stubs like mkCompare allocate storage, which should be released with freeHaskellFunPtr when no longer required.

To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g.

type IntFunction = CInt -> IO ()
foreign import ccall "dynamic"
  mkFun :: FunPtr IntFunction -> IntFunction

Instances

Instances details

NFData1 FunPtr	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> FunPtr a -> () Source #
IArray UArray ( FunPtr a)
Instance details Defined in Data.Array.Base Methods bounds :: Ix i => UArray i ( FunPtr a) -> (i, i) Source # numElements :: Ix i => UArray i ( FunPtr a) -> Int unsafeArray :: Ix i => (i, i) -> [( Int , FunPtr a)] -> UArray i ( FunPtr a) unsafeAt :: Ix i => UArray i ( FunPtr a) -> Int -> FunPtr a unsafeReplace :: Ix i => UArray i ( FunPtr a) -> [( Int , FunPtr a)] -> UArray i ( FunPtr a) unsafeAccum :: Ix i => ( FunPtr a -> e' -> FunPtr a) -> UArray i ( FunPtr a) -> [( Int , e')] -> UArray i ( FunPtr a) unsafeAccumArray :: Ix i => ( FunPtr a -> e' -> FunPtr a) -> FunPtr a -> (i, i) -> [( Int , e')] -> UArray i ( FunPtr a)
Eq ( FunPtr a)
Instance details Defined in GHC.Ptr Methods (==) :: FunPtr a -> FunPtr a -> Bool Source # (/=) :: FunPtr a -> FunPtr a -> Bool Source #
Ord ( FunPtr a)
Instance details Defined in GHC.Ptr Methods compare :: FunPtr a -> FunPtr a -> Ordering Source # (<) :: FunPtr a -> FunPtr a -> Bool Source # (<=) :: FunPtr a -> FunPtr a -> Bool Source # (>) :: FunPtr a -> FunPtr a -> Bool Source # (>=) :: FunPtr a -> FunPtr a -> Bool Source # max :: FunPtr a -> FunPtr a -> FunPtr a Source # min :: FunPtr a -> FunPtr a -> FunPtr a Source #
Show ( FunPtr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> FunPtr a -> ShowS Source # show :: FunPtr a -> String Source # showList :: [ FunPtr a] -> ShowS Source #
Hashable ( FunPtr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> FunPtr a -> Int Source # hash :: FunPtr a -> Int Source #
Storable ( FunPtr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: FunPtr a -> Int Source # alignment :: FunPtr a -> Int Source # peekElemOff :: Ptr ( FunPtr a) -> Int -> IO ( FunPtr a) Source # pokeElemOff :: Ptr ( FunPtr a) -> Int -> FunPtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( FunPtr a) Source # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () Source # peek :: Ptr ( FunPtr a) -> IO ( FunPtr a) Source # poke :: Ptr ( FunPtr a) -> FunPtr a -> IO () Source #
NFData ( FunPtr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: FunPtr a -> () Source #
Prim ( FunPtr a)
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: FunPtr a -> Int# Source # alignment# :: FunPtr a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> FunPtr a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FunPtr a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> FunPtr a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> FunPtr a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> FunPtr a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, FunPtr a #) Source # writeOffAddr# :: Addr# -> Int# -> FunPtr a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> FunPtr a -> State# s -> State# s Source #
MArray ( STUArray s) ( FunPtr a) ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i ( FunPtr a) -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i ( FunPtr a) -> ST s Int newArray :: Ix i => (i, i) -> FunPtr a -> ST s ( STUArray s i ( FunPtr a)) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( FunPtr a)) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( FunPtr a)) unsafeRead :: Ix i => STUArray s i ( FunPtr a) -> Int -> ST s ( FunPtr a) unsafeWrite :: Ix i => STUArray s i ( FunPtr a) -> Int -> FunPtr a -> ST s ()

data Either a b Source #

The Either type represents values with two possibilities: a value of type Either a b is either Left a or Right b .

The Either type is sometimes used to represent a value which is either correct or an error; by convention, the Left constructor is used to hold an error value and the Right constructor is used to hold a correct value (mnemonic: "right" also means "correct").

Examples

Expand

The type Either String Int is the type of values which can be either a String or an Int . The Left constructor can be used only on String s, and the Right constructor can be used only on Int s:

>>> let s = Left "foo" :: Either String Int
>>> s
Left "foo"
>>> let n = Right 3 :: Either String Int
>>> n
Right 3
>>> :type s
s :: Either String Int
>>> :type n
n :: Either String Int

The fmap from our Functor instance will ignore Left values, but will apply the supplied function to values contained in a Right :

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> fmap (*2) s
Left "foo"
>>> fmap (*2) n
Right 6

The Monad instance for Either allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an Int from a Char , or fail.

>>> import Data.Char ( digitToInt, isDigit )
>>> :{
    let parseEither :: Char -> Either String Int
        parseEither c
          | isDigit c = Right (digitToInt c)
          | otherwise = Left "parse error"
>>> :}

The following should work, since both '1' and '2' can be parsed as Int s.

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither '1'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Right 3

But the following should fail overall, since the first operation where we attempt to parse 'm' as an Int will fail:

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither 'm'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Left "parse error"

Constructors

Left a
Right b

Instances

Instances details

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d Source # first :: (a -> b) -> Either a c -> Either b c Source # second :: (b -> c) -> Either a b -> Either a c Source #
Bifoldable Either	Since: base-4.10.0.0
Instance details Defined in Data.Bifoldable Methods bifold :: Monoid m => Either m m -> m Source # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Either a b -> m Source # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Either a b -> c Source # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Either a b -> c Source #
NFData2 Either	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Either a b -> () Source #
Hashable2 Either
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: ( Int -> a -> Int ) -> ( Int -> b -> Int ) -> Int -> Either a b -> Int Source #
MonadError e ( Either e)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> Either e a Source # catchError :: Either e a -> (e -> Either e a) -> Either e a Source #
( Lift a, Lift b) => Lift ( Either a b :: Type )
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Either a b -> Q Exp Source # liftTyped :: Either a b -> Q ( TExp ( Either a b)) Source #
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 Source # (>>) :: Either e a -> Either e b -> Either e b Source # return :: a -> Either e a Source #
Functor ( Either a)	Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b Source # (<$) :: a0 -> Either a b -> Either a a0 Source #
Applicative ( Either e)	Since: base-3.0
Instance details Defined in Data.Either Methods pure :: a -> Either e a Source # (<>) :: Either e (a -> b) -> Either e a -> Either e b Source # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c Source # (>) :: Either e a -> Either e b -> Either e b Source # (<*) :: Either e a -> Either e b -> Either e a Source #
Foldable ( Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 Source # toList :: Either a a0 -> [a0] Source # null :: Either a a0 -> Bool Source # length :: Either a a0 -> Int Source # elem :: Eq a0 => a0 -> Either a a0 -> Bool Source # maximum :: Ord a0 => Either a a0 -> a0 Source # minimum :: Ord a0 => Either a a0 -> a0 Source # sum :: Num a0 => Either a a0 -> a0 Source # product :: Num a0 => Either a a0 -> a0 Source #
Traversable ( Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f ( Either a b) Source # sequenceA :: Applicative f => Either a (f a0) -> f ( Either a a0) Source # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m ( Either a b) Source # sequence :: Monad m => Either a (m a0) -> m ( Either a a0) Source #
NFData a => NFData1 ( Either a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> Either a a0 -> () Source #
Hashable a => Hashable1 ( Either a)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a0 -> Int ) -> Int -> Either a a0 -> Int Source #
Generic1 ( Either a :: Type -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( Either a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Either a a0 -> Rep1 ( Either a) a0 Source # to1 :: forall (a0 :: k). Rep1 ( Either a) a0 -> Either a a0 Source #
( Eq a, Eq b) => Eq ( Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods (==) :: Either a b -> Either a b -> Bool Source # (/=) :: Either a b -> Either a b -> Bool Source #
( Ord a, Ord b) => Ord ( Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering Source # (<) :: Either a b -> Either a b -> Bool Source # (<=) :: Either a b -> Either a b -> Bool Source # (>) :: Either a b -> Either a b -> Bool Source # (>=) :: Either a b -> Either a b -> Bool Source # max :: Either a b -> Either a b -> Either a b Source # min :: Either a b -> Either a b -> Either a b Source #
( Read a, Read b) => Read ( Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods readsPrec :: Int -> ReadS ( Either a b) Source # readList :: ReadS [ Either a b] Source # readPrec :: ReadPrec ( Either a b) Source # readListPrec :: ReadPrec [ Either a b] Source #
( 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 Source # show :: Either a b -> String Source # showList :: [ Either a b] -> ShowS Source #
Generic ( Either a b)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Either a b) :: Type -> Type Source # Methods from :: Either a b -> Rep ( Either a b) x Source # to :: Rep ( Either a b) x -> Either a b Source #
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 Source # sconcat :: NonEmpty ( Either a b) -> Either a b Source # stimes :: Integral b0 => b0 -> Either a b -> Either a b Source #
( Hashable a, Hashable b) => Hashable ( Either a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Either a b -> Int Source # hash :: Either a b -> Int Source #
( NFData a, NFData b) => NFData ( Either a b)
Instance details Defined in Control.DeepSeq Methods rnf :: Either a b -> () Source #
( HeapWords a, HeapWords b) => HeapWords ( Either a b) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Either a b -> Int Source #
type Rep1 ( Either a :: Type -> Type )
Instance details Defined in GHC.Generics type Rep1 ( Either a :: Type -> Type ) = D1 (' MetaData "Either" "Data.Either" "base" ' False ) ( C1 (' MetaCons "Left" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :+: C1 (' MetaCons "Right" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 ))
type Rep ( Either a b)
Instance details Defined in GHC.Generics type Rep ( Either a b) = D1 (' MetaData "Either" "Data.Either" "base" ' False ) ( C1 (' MetaCons "Left" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :+: C1 (' MetaCons "Right" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)))

type Type = Type Source #

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

data Constraint Source #

The kind of constraints, like Show a

data V1 (p :: k) Source #

Void: used for datatypes without constructors

Instances

Instances details

Generic1 ( V1 :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 V1 :: k -> Type Source # Methods from1 :: forall (a :: k0). V1 a -> Rep1 V1 a Source # to1 :: forall (a :: k0). Rep1 V1 a -> V1 a Source #
GNFData arity ( V1 :: Type -> Type )
Instance details Defined in Control.DeepSeq Methods grnf :: RnfArgs arity a -> V1 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 Source # (<$) :: a -> V1 b -> V1 a Source #
Foldable ( V1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => V1 m -> m Source # foldMap :: Monoid m => (a -> m) -> V1 a -> m Source # foldMap' :: Monoid m => (a -> m) -> V1 a -> m Source # foldr :: (a -> b -> b) -> b -> V1 a -> b Source # foldr' :: (a -> b -> b) -> b -> V1 a -> b Source # foldl :: (b -> a -> b) -> b -> V1 a -> b Source # foldl' :: (b -> a -> b) -> b -> V1 a -> b Source # foldr1 :: (a -> a -> a) -> V1 a -> a Source # foldl1 :: (a -> a -> a) -> V1 a -> a Source # toList :: V1 a -> [a] Source # null :: V1 a -> Bool Source # length :: V1 a -> Int Source # elem :: Eq a => a -> V1 a -> Bool Source # maximum :: Ord a => V1 a -> a Source # minimum :: Ord a => V1 a -> a Source # sum :: Num a => V1 a -> a Source # product :: Num a => V1 a -> a Source #
Traversable ( V1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f ( V1 b) Source # sequenceA :: Applicative f => V1 (f a) -> f ( V1 a) Source # mapM :: Monad m => (a -> m b) -> V1 a -> m ( V1 b) Source # sequence :: Monad m => V1 (m a) -> m ( V1 a) Source #
Eq ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: V1 p -> V1 p -> Bool Source # (/=) :: V1 p -> V1 p -> Bool Source #
Ord ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: V1 p -> V1 p -> Ordering Source # (<) :: V1 p -> V1 p -> Bool Source # (<=) :: V1 p -> V1 p -> Bool Source # (>) :: V1 p -> V1 p -> Bool Source # (>=) :: V1 p -> V1 p -> Bool Source # max :: V1 p -> V1 p -> V1 p Source # min :: V1 p -> V1 p -> V1 p Source #
Read ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( V1 p) Source # readList :: ReadS [ V1 p] Source # readPrec :: ReadPrec ( V1 p) Source # readListPrec :: ReadPrec [ V1 p] Source #
Show ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> V1 p -> ShowS Source # show :: V1 p -> String Source # showList :: [ V1 p] -> ShowS Source #
Generic ( V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( V1 p) :: Type -> Type Source # Methods from :: V1 p -> Rep ( V1 p) x Source # to :: Rep ( V1 p) x -> V1 p Source #
Semigroup ( V1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: V1 p -> V1 p -> V1 p Source # sconcat :: NonEmpty ( V1 p) -> V1 p Source # stimes :: Integral b => b -> V1 p -> V1 p Source #
type Rep1 ( V1 :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 ( V1 :: k -> Type ) = D1 (' MetaData "V1" "GHC.Generics" "base" ' False ) ( V1 :: k -> Type )
type Rep ( V1 p)
Instance details Defined in GHC.Generics type Rep ( V1 p) = D1 (' MetaData "V1" "GHC.Generics" "base" ' False ) ( V1 :: Type -> Type )

data U1 (p :: k) Source #

Unit: used for constructors without arguments

Constructors

U1

Instances

Instances details

Generic1 ( U1 :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 U1 :: k -> Type Source # Methods from1 :: forall (a :: k0). U1 a -> Rep1 U1 a Source # to1 :: forall (a :: k0). Rep1 U1 a -> U1 a Source #
GNFData arity ( U1 :: Type -> Type )
Instance details Defined in Control.DeepSeq Methods grnf :: RnfArgs arity a -> U1 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 Source # (>>) :: U1 a -> U1 b -> U1 b Source # return :: a -> U1 a Source #
Functor ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b Source # (<$) :: a -> U1 b -> U1 a Source #
Applicative ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> U1 a Source # (<>) :: U1 (a -> b) -> U1 a -> U1 b Source # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source # (>) :: U1 a -> U1 b -> U1 b Source # (<*) :: U1 a -> U1 b -> U1 a Source #
Foldable ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => U1 m -> m Source # foldMap :: Monoid m => (a -> m) -> U1 a -> m Source # foldMap' :: Monoid m => (a -> m) -> U1 a -> m Source # foldr :: (a -> b -> b) -> b -> U1 a -> b Source # foldr' :: (a -> b -> b) -> b -> U1 a -> b Source # foldl :: (b -> a -> b) -> b -> U1 a -> b Source # foldl' :: (b -> a -> b) -> b -> U1 a -> b Source # foldr1 :: (a -> a -> a) -> U1 a -> a Source # foldl1 :: (a -> a -> a) -> U1 a -> a Source # toList :: U1 a -> [a] Source # null :: U1 a -> Bool Source # length :: U1 a -> Int Source # elem :: Eq a => a -> U1 a -> Bool Source # maximum :: Ord a => U1 a -> a Source # minimum :: Ord a => U1 a -> a Source # sum :: Num a => U1 a -> a Source # product :: Num a => U1 a -> a Source #
Traversable ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f ( U1 b) Source # sequenceA :: Applicative f => U1 (f a) -> f ( U1 a) Source # mapM :: Monad m => (a -> m b) -> U1 a -> m ( U1 b) Source # sequence :: Monad m => U1 (m a) -> m ( U1 a) Source #
Alternative ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: U1 a Source # (<\|>) :: U1 a -> U1 a -> U1 a Source # some :: U1 a -> U1 [a] Source # many :: U1 a -> U1 [a] Source #
MonadPlus ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: U1 a Source # mplus :: U1 a -> U1 a -> U1 a Source #
GUniform ( U1 :: Type -> Type )
Instance details Defined in System.Random.Internal Methods guniformM :: forall g (m :: Type -> Type ) r a. StatefulGen g m => g -> ContT r m ( U1 a)
Eq ( U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: U1 p -> U1 p -> Bool Source # (/=) :: U1 p -> U1 p -> Bool Source #
Ord ( U1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: U1 p -> U1 p -> Ordering Source # (<) :: U1 p -> U1 p -> Bool Source # (<=) :: U1 p -> U1 p -> Bool Source # (>) :: U1 p -> U1 p -> Bool Source # (>=) :: U1 p -> U1 p -> Bool Source # max :: U1 p -> U1 p -> U1 p Source # min :: U1 p -> U1 p -> U1 p Source #
Read ( U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( U1 p) Source # readList :: ReadS [ U1 p] Source # readPrec :: ReadPrec ( U1 p) Source # readListPrec :: ReadPrec [ U1 p] Source #
Show ( U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> U1 p -> ShowS Source # show :: U1 p -> String Source # showList :: [ U1 p] -> ShowS Source #
Generic ( U1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( U1 p) :: Type -> Type Source # Methods from :: U1 p -> Rep ( U1 p) x Source # to :: Rep ( U1 p) x -> U1 p Source #
Semigroup ( U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: U1 p -> U1 p -> U1 p Source # sconcat :: NonEmpty ( U1 p) -> U1 p Source # stimes :: Integral b => b -> U1 p -> U1 p Source #
Monoid ( U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: U1 p Source # mappend :: U1 p -> U1 p -> U1 p Source # mconcat :: [ U1 p] -> U1 p Source #
type Rep1 ( U1 :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 ( U1 :: k -> Type ) = D1 (' MetaData "U1" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "U1" ' PrefixI ' False ) ( U1 :: k -> Type ))
type Rep ( U1 p)
Instance details Defined in GHC.Generics type Rep ( U1 p) = D1 (' MetaData "U1" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "U1" ' PrefixI ' False ) ( U1 :: Type -> Type ))

newtype K1 i c (p :: k) Source #

Constants, additional parameters and recursion of kind *

Constructors

K1
Fields unK1 :: c

Instances

Instances details

Generic1 ( K1 i c :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( K1 i c) :: k -> Type Source # Methods from1 :: forall (a :: k0). K1 i c a -> Rep1 ( K1 i c) a Source # to1 :: forall (a :: k0). Rep1 ( K1 i c) a -> K1 i c a Source #
NFData a => GNFData arity ( K1 i a :: Type -> Type )
Instance details Defined in Control.DeepSeq Methods grnf :: RnfArgs arity a0 -> K1 i a a0 -> ()
Bifunctor ( K1 i :: Type -> Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d Source # first :: (a -> b) -> K1 i a c -> K1 i b c Source # second :: (b -> c) -> K1 i a b -> K1 i a c Source #
Bifoldable ( K1 i :: Type -> Type -> Type )	Since: base-4.10.0.0
Instance details Defined in Data.Bifoldable Methods bifold :: Monoid m => K1 i m m -> m Source # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> K1 i a b -> m Source # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> K1 i a b -> c Source # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> K1 i a b -> c Source #
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 Source # (<$) :: a -> K1 i c b -> K1 i c a Source #
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 Source # (<>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b Source # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 Source # (>) :: K1 i c a -> K1 i c b -> K1 i c b Source # (<*) :: K1 i c a -> K1 i c b -> K1 i c a Source #
Foldable ( K1 i c :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m Source # foldMap :: Monoid m => (a -> m) -> K1 i c a -> m Source # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m Source # foldr :: (a -> b -> b) -> b -> K1 i c a -> b Source # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b Source # foldl :: (b -> a -> b) -> b -> K1 i c a -> b Source # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b Source # foldr1 :: (a -> a -> a) -> K1 i c a -> a Source # foldl1 :: (a -> a -> a) -> K1 i c a -> a Source # toList :: K1 i c a -> [a] Source # null :: K1 i c a -> Bool Source # length :: K1 i c a -> Int Source # elem :: Eq a => a -> K1 i c a -> Bool Source # maximum :: Ord a => K1 i c a -> a Source # minimum :: Ord a => K1 i c a -> a Source # sum :: Num a => K1 i c a -> a Source # product :: Num a => K1 i c a -> a Source #
Traversable ( K1 i c :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f ( K1 i c b) Source # sequenceA :: Applicative f => K1 i c (f a) -> f ( K1 i c a) Source # mapM :: Monad m => (a -> m b) -> K1 i c a -> m ( K1 i c b) Source # sequence :: Monad m => K1 i c (m a) -> m ( K1 i c a) Source #
Uniform a => GUniform ( K1 i a :: Type -> Type )
Instance details Defined in System.Random.Internal Methods guniformM :: forall g (m :: Type -> Type ) r a0. StatefulGen g m => g -> ContT r m ( K1 i a a0)
Eq c => Eq ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: K1 i c p -> K1 i c p -> Bool Source # (/=) :: K1 i c p -> K1 i c p -> Bool Source #
Ord c => Ord ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: K1 i c p -> K1 i c p -> Ordering Source # (<) :: K1 i c p -> K1 i c p -> Bool Source # (<=) :: K1 i c p -> K1 i c p -> Bool Source # (>) :: K1 i c p -> K1 i c p -> Bool Source # (>=) :: K1 i c p -> K1 i c p -> Bool Source # max :: K1 i c p -> K1 i c p -> K1 i c p Source # min :: K1 i c p -> K1 i c p -> K1 i c p Source #
Read c => Read ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( K1 i c p) Source # readList :: ReadS [ K1 i c p] Source # readPrec :: ReadPrec ( K1 i c p) Source # readListPrec :: ReadPrec [ K1 i c p] Source #
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 Source # show :: K1 i c p -> String Source # showList :: [ K1 i c p] -> ShowS Source #
Generic ( K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( K1 i c p) :: Type -> Type Source # Methods from :: K1 i c p -> Rep ( K1 i c p) x Source # to :: Rep ( K1 i c p) x -> K1 i c p Source #
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 Source # sconcat :: NonEmpty ( K1 i c p) -> K1 i c p Source # stimes :: Integral b => b -> K1 i c p -> K1 i c p Source #
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 Source # mappend :: K1 i c p -> K1 i c p -> K1 i c p Source # mconcat :: [ K1 i c p] -> K1 i c p Source #
type Rep1 ( K1 i c :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 ( K1 i c :: k -> Type ) = D1 (' MetaData "K1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "K1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unK1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c)))
type Rep ( K1 i c p)
Instance details Defined in GHC.Generics type Rep ( K1 i c p) = D1 (' MetaData "K1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "K1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unK1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c)))

newtype M1 i (c :: Meta ) (f :: k -> Type ) (p :: k) Source #

Meta-information (constructor names, etc.)

Constructors

M1
Fields unM1 :: f p

Instances

Instances details

GHashable arity a => GSum arity ( C1 c a)
Instance details Defined in Data.Hashable.Generic.Instances Methods hashSum :: HashArgs arity a0 -> Int -> Int -> C1 c a a0 -> Int
Generic1 ( M1 i c f :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( M1 i c f) :: k -> Type Source # Methods from1 :: forall (a :: k0). M1 i c f a -> Rep1 ( M1 i c f) a Source # to1 :: forall (a :: k0). Rep1 ( M1 i c f) a -> M1 i c f a Source #
GNFData arity a => GNFData arity ( M1 i c a)
Instance details Defined in Control.DeepSeq Methods grnf :: RnfArgs arity a0 -> M1 i c a a0 -> ()
SumSize ( C1 c a)
Instance details Defined in Data.Hashable.Generic.Instances Methods sumSize :: Tagged ( C1 c a)
GBinaryGet a => GSumGet ( C1 c a)
Instance details Defined in Data.Binary.Generic Methods getSum :: ( Ord word, Num word, Bits word) => word -> word -> Get ( C1 c a a0)
SumSize ( C1 c a)
Instance details Defined in Data.Binary.Generic Methods sumSize :: Tagged ( C1 c a) Word64
GBinaryPut a => GSumPut ( C1 c a)
Instance details Defined in Data.Binary.Generic Methods putSum :: ( Num w, Bits w, Binary w) => w -> w -> C1 c a a0 -> Put
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 Source # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source # return :: a -> M1 i c f a Source #
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 Source # (<$) :: a -> M1 i c f b -> M1 i c f a Source #
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 Source # (<>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b Source # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 Source # (>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source # (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a Source #
Foldable f => Foldable ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m Source # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m Source # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m Source # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b Source # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b Source # foldl :: (b -> a -> b) -> b -> M1 i c f a -> b Source # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b Source # foldr1 :: (a -> a -> a) -> M1 i c f a -> a Source # foldl1 :: (a -> a -> a) -> M1 i c f a -> a Source # toList :: M1 i c f a -> [a] Source # null :: M1 i c f a -> Bool Source # length :: M1 i c f a -> Int Source # elem :: Eq a => a -> M1 i c f a -> Bool Source # maximum :: Ord a => M1 i c f a -> a Source # minimum :: Ord a => M1 i c f a -> a Source # sum :: Num a => M1 i c f a -> a Source # product :: Num a => M1 i c f a -> a Source #
Traversable f => Traversable ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 ( M1 i c f b) Source # sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 ( M1 i c f a) Source # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m ( M1 i c f b) Source # sequence :: Monad m => M1 i c f (m a) -> m ( M1 i c f a) Source #
Alternative f => Alternative ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: M1 i c f a Source # (<\|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a Source # some :: M1 i c f a -> M1 i c f [a] Source # many :: M1 i c f a -> M1 i c f [a] Source #
MonadPlus f => MonadPlus ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: M1 i c f a Source # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a Source #
GUniform f => GUniform ( M1 i c f)
Instance details Defined in System.Random.Internal Methods guniformM :: forall g (m :: Type -> Type ) r a. StatefulGen g m => g -> ContT r m ( M1 i c f a)
Eq (f p) => Eq ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: M1 i c f p -> M1 i c f p -> Bool Source # (/=) :: M1 i c f p -> M1 i c f p -> Bool Source #
Ord (f p) => Ord ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: M1 i c f p -> M1 i c f p -> Ordering Source # (<) :: M1 i c f p -> M1 i c f p -> Bool Source # (<=) :: M1 i c f p -> M1 i c f p -> Bool Source # (>) :: M1 i c f p -> M1 i c f p -> Bool Source # (>=) :: M1 i c f p -> M1 i c f p -> Bool Source # max :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # min :: M1 i c f p -> M1 i c f p -> M1 i c f p Source #
Read (f p) => Read ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ( M1 i c f p) Source # readList :: ReadS [ M1 i c f p] Source # readPrec :: ReadPrec ( M1 i c f p) Source # readListPrec :: ReadPrec [ M1 i c f p] Source #
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 Source # show :: M1 i c f p -> String Source # showList :: [ M1 i c f p] -> ShowS Source #
Generic ( M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( M1 i c f p) :: Type -> Type Source # Methods from :: M1 i c f p -> Rep ( M1 i c f p) x Source # to :: Rep ( M1 i c f p) x -> M1 i c f p Source #
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 Source # sconcat :: NonEmpty ( M1 i c f p) -> M1 i c f p Source # stimes :: Integral b => b -> M1 i c f p -> M1 i c f p Source #
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 Source # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # mconcat :: [ M1 i c f p] -> M1 i c f p Source #
type Rep1 ( M1 i c f :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 ( M1 i c f :: k -> Type ) = D1 (' MetaData "M1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "M1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unM1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 f)))
type Rep ( M1 i c f p)
Instance details Defined in GHC.Generics type Rep ( M1 i c f p) = D1 (' MetaData "M1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "M1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unM1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f p))))

data ((f :: k -> Type ) :+: (g :: k -> Type )) (p :: k) infixr 5 Source #

Sums: encode choice between constructors

Constructors

L1 (f p)
R1 (g p)

Instances

Instances details

Generic1 (f :+: g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :+: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :+: g) a -> Rep1 (f :+: g) a Source # to1 :: forall (a :: k0). Rep1 (f :+: g) a -> (f :+: g) a Source #
(GSum arity a, GSum arity b) => GSum arity (a :+: b)
Instance details Defined in Data.Hashable.Generic.Instances Methods hashSum :: HashArgs arity a0 -> Int -> Int -> (a :+: b) a0 -> Int
(GNFData arity a, GNFData arity b) => GNFData arity (a :+: b)
Instance details Defined in Control.DeepSeq Methods grnf :: RnfArgs arity a0 -> (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 Source # (<$) :: a -> (f :+: g) b -> (f :+: g) a Source #
( Foldable f, Foldable g) => Foldable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m Source # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m Source # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b Source # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b Source # foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b Source # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b Source # foldr1 :: (a -> a -> a) -> (f :+: g) a -> a Source # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a Source # toList :: (f :+: g) a -> [a] Source # null :: (f :+: g) a -> Bool Source # length :: (f :+: g) a -> Int Source # elem :: Eq a => a -> (f :+: g) a -> Bool Source # maximum :: Ord a => (f :+: g) a -> a Source # minimum :: Ord a => (f :+: g) a -> a Source # sum :: Num a => (f :+: g) a -> a Source # product :: Num a => (f :+: g) a -> a Source #
( Traversable f, Traversable g) => Traversable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) Source # sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) Source # sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) Source #
(GFinite f, GFinite g) => GUniform (f :+: g)
Instance details Defined in System.Random.Internal Methods guniformM :: forall g0 (m :: Type -> Type ) r a. StatefulGen g0 m => g0 -> ContT r m ((f :+: g) a)
(SumSize a, SumSize b) => SumSize (a :+: b)
Instance details Defined in Data.Hashable.Generic.Instances Methods sumSize :: Tagged (a :+: b)
(GSumGet a, GSumGet b) => GSumGet (a :+: b)
Instance details Defined in Data.Binary.Generic Methods getSum :: ( Ord word, Num word, Bits word) => word -> word -> Get ((a :+: b) a0)
(SumSize a, SumSize b) => SumSize (a :+: b)
Instance details Defined in Data.Binary.Generic Methods sumSize :: Tagged (a :+: b) Word64
(GSumPut a, GSumPut b) => GSumPut (a :+: b)
Instance details Defined in Data.Binary.Generic Methods putSum :: ( Num w, Bits w, Binary w) => w -> w -> (a :+: b) a0 -> Put
( Eq (f p), Eq (g p)) => Eq ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool Source #
( Ord (f p), Ord (g p)) => Ord ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :+: g) p -> (f :+: g) p -> Ordering Source # (<) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (<=) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>=) :: (f :+: g) p -> (f :+: g) p -> Bool Source # max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source # min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source #
( Read (f p), Read (g p)) => Read ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :+: g) p) Source # readList :: ReadS [(f :+: g) p] Source # readPrec :: ReadPrec ((f :+: g) p) Source # readListPrec :: ReadPrec [(f :+: g) p] Source #
( 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 Source # show :: (f :+: g) p -> String Source # showList :: [(f :+: g) p] -> ShowS Source #
Generic ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type Source # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x Source # to :: Rep ((f :+: g) p) x -> (f :+: g) p Source #
type Rep1 (f :+: g :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 (f :+: g :: k -> Type ) = D1 (' MetaData ":+:" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "L1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 f)) :+: C1 (' MetaCons "R1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 g)))
type Rep ((f :+: g) p)
Instance details Defined in GHC.Generics type Rep ((f :+: g) p) = D1 (' MetaData ":+:" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "L1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f p))) :+: C1 (' MetaCons "R1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g p))))

data ((f :: k -> Type ) :*: (g :: k -> Type )) (p :: k) infixr 6 Source #

Products: encode multiple arguments to constructors

Constructors

(f p) :*: (g p) infixr 6

Instances

Instances details

Generic1 (f :*: g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :: g) a -> Rep1 (f :: g) a Source # to1 :: forall (a :: k0). Rep1 (f :: g) a -> (f :*: g) a Source #
(GNFData arity a, GNFData arity b) => GNFData arity (a :*: b)
Instance details Defined in Control.DeepSeq Methods grnf :: RnfArgs arity 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 Source # (>>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # return :: a -> (f :*: g) a Source #
( 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 Source # (<$) :: a -> (f :: g) b -> (f :: g) a Source #
( 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 Source # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b Source # liftA2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c Source # (>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # (<) :: (f :: g) a -> (f :: g) b -> (f :: g) a Source #
( Foldable f, Foldable g) => Foldable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :: g) a -> m Source # foldMap' :: Monoid m => (a -> m) -> (f :: g) a -> m Source # foldr :: (a -> b -> b) -> b -> (f :: g) a -> b Source # foldr' :: (a -> b -> b) -> b -> (f :: g) a -> b Source # foldl :: (b -> a -> b) -> b -> (f :: g) a -> b Source # foldl' :: (b -> a -> b) -> b -> (f :: g) a -> b Source # foldr1 :: (a -> a -> a) -> (f :: g) a -> a Source # foldl1 :: (a -> a -> a) -> (f :: g) a -> a Source # toList :: (f :: g) a -> [a] Source # null :: (f :: g) a -> Bool Source # length :: (f :: g) a -> Int Source # elem :: Eq a => a -> (f :: g) a -> Bool Source # maximum :: Ord a => (f :: g) a -> a Source # minimum :: Ord a => (f :: g) a -> a Source # sum :: Num a => (f :: g) a -> a Source # product :: Num a => (f :*: g) a -> a Source #
( Traversable f, Traversable g) => Traversable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) Source # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((f :: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) Source # sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a) Source #
( Alternative f, Alternative g) => Alternative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :: g) a Source # (<\|>) :: (f :: g) a -> (f :: g) a -> (f :: g) a Source # some :: (f :: g) a -> (f :: g) [a] Source # many :: (f :: g) a -> (f :: g) [a] Source #
( MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: (f :: g) a Source # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a Source #
(GUniform f, GUniform g) => GUniform (f :*: g)
Instance details Defined in System.Random.Internal Methods guniformM :: forall g0 (m :: Type -> Type ) r a. StatefulGen g0 m => g0 -> ContT r m ((f :*: g) a)
( Eq (f p), Eq (g p)) => Eq ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :: g) p -> (f :: g) p -> Bool Source # (/=) :: (f :: g) p -> (f :: g) p -> Bool Source #
( Ord (f p), Ord (g p)) => Ord ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :: g) p -> (f :: g) p -> Ordering Source # (<) :: (f :: g) p -> (f :: g) p -> Bool Source # (<=) :: (f :: g) p -> (f :: g) p -> Bool Source # (>) :: (f :: g) p -> (f :: g) p -> Bool Source # (>=) :: (f :: g) p -> (f :: g) p -> Bool Source # max :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # min :: (f :: g) p -> (f :: g) p -> (f :: g) p Source #
( Read (f p), Read (g p)) => Read ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :: g) p) Source # readList :: ReadS [(f :: g) p] Source # readPrec :: ReadPrec ((f :: g) p) Source # readListPrec :: ReadPrec [(f :: g) p] Source #
( 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 Source # show :: (f :: g) p -> String Source # showList :: [(f :*: g) p] -> ShowS Source #
Generic ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type Source # Methods from :: (f :: g) p -> Rep ((f :: g) p) x Source # to :: Rep ((f :: g) p) x -> (f :*: g) p Source #
( 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 Source # sconcat :: NonEmpty ((f :: g) p) -> (f :: g) p Source # stimes :: Integral b => b -> (f :: g) p -> (f :*: g) p Source #
( 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 Source # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # mconcat :: [(f :: g) p] -> (f :: g) p Source #
type Rep1 (f :*: g :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 (f :: g :: k -> Type ) = D1 (' MetaData "::" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "::" (' InfixI ' RightAssociative 6) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 f) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 g)))
type Rep ((f :*: g) p)
Instance details Defined in GHC.Generics type Rep ((f :: g) p) = D1 (' MetaData "::" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "::" (' InfixI ' RightAssociative 6) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f p)) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g p))))

newtype ((f :: k2 -> Type ) :.: (g :: k1 -> k2)) (p :: k1) infixr 7 Source #

Composition of functors

Constructors

Comp1
Fields unComp1 :: f (g p)

Instances

Instances details

Functor f => Generic1 (f :.: g :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :.: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a Source # to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a Source #
( NFData1 f, GNFData One g) => GNFData One (f :.: g)
Instance details Defined in Control.DeepSeq Methods grnf :: RnfArgs One a -> (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 Source # (<$) :: a -> (f :.: g) b -> (f :.: g) a Source #
( 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 Source # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c Source # (>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b Source # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a Source #
( Foldable f, Foldable g) => Foldable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m Source # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m Source # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b Source # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b Source # foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b Source # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b Source # foldr1 :: (a -> a -> a) -> (f :.: g) a -> a Source # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a Source # toList :: (f :.: g) a -> [a] Source # null :: (f :.: g) a -> Bool Source # length :: (f :.: g) a -> Int Source # elem :: Eq a => a -> (f :.: g) a -> Bool Source # maximum :: Ord a => (f :.: g) a -> a Source # minimum :: Ord a => (f :.: g) a -> a Source # sum :: Num a => (f :.: g) a -> a Source # product :: Num a => (f :.: g) a -> a Source #
( Traversable f, Traversable g) => Traversable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) Source # sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) Source # sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) Source #
( Alternative f, Applicative g) => Alternative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :.: g) a Source # (<\|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a Source # some :: (f :.: g) a -> (f :.: g) [a] Source # many :: (f :.: g) a -> (f :.: g) [a] Source #
Eq (f (g p)) => Eq ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool Source #
Ord (f (g p)) => Ord ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :.: g) p -> (f :.: g) p -> Ordering Source # (<) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (<=) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>=) :: (f :.: g) p -> (f :.: g) p -> Bool Source # max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source #
Read (f (g p)) => Read ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :.: g) p) Source # readList :: ReadS [(f :.: g) p] Source # readPrec :: ReadPrec ((f :.: g) p) Source # readListPrec :: ReadPrec [(f :.: g) p] Source #
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 Source # show :: (f :.: g) p -> String Source # showList :: [(f :.: g) p] -> ShowS Source #
Generic ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type Source # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x Source # to :: Rep ((f :.: g) p) x -> (f :.: g) p Source #
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 Source # sconcat :: NonEmpty ((f :.: g) p) -> (f :.: g) p Source # stimes :: Integral b => b -> (f :.: g) p -> (f :.: g) p Source #
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 Source # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # mconcat :: [(f :.: g) p] -> (f :.: g) p Source #
type Rep1 (f :.: g :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 (f :.: g :: k -> Type ) = D1 (' MetaData ":.:" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "Comp1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unComp1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) (f :.: Rec1 g)))
type Rep ((f :.: g) p)
Instance details Defined in GHC.Generics type Rep ((f :.: g) p) = D1 (' MetaData ":.:" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "Comp1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unComp1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f (g p)))))

type Rec0 = K1 R :: Type -> k -> Type Source #

Type synonym for encoding recursion (of kind Type )

type D1 = M1 D :: Meta -> (k -> Type ) -> k -> Type Source #

Type synonym for encoding meta-information for datatypes

type C1 = M1 C :: Meta -> (k -> Type ) -> k -> Type Source #

Type synonym for encoding meta-information for constructors

type S1 = M1 S :: Meta -> (k -> Type ) -> k -> Type Source #

Type synonym for encoding meta-information for record selectors

type family Rep a :: Type -> Type Source #

Generic representation type

Instances

Instances details

type Rep Bool
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 ))
type Rep Ordering
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 )))
type Rep Exp
Instance details Defined in Language.Haskell.TH.Syntax type Rep Exp = D1 (' MetaData "Exp" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (((( C1 (' MetaCons "VarE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: ( C1 (' MetaCons "ConE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: C1 (' MetaCons "LitE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Lit )))) :+: (( C1 (' MetaCons "AppE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "AppTypeE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :+: ( C1 (' MetaCons "InfixE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Exp )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Exp )))) :+: C1 (' MetaCons "UInfixE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )))))) :+: (( C1 (' MetaCons "ParensE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: ( C1 (' MetaCons "LamE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Pat ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "LamCaseE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Match ])))) :+: (( C1 (' MetaCons "TupE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Maybe Exp ])) :+: C1 (' MetaCons "UnboxedTupE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Maybe Exp ]))) :+: ( C1 (' MetaCons "UnboxedSumE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 SumAlt ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 SumArity ))) :+: C1 (' MetaCons "CondE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ))))))) :+: ((( C1 (' MetaCons "MultiIfE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [( Guard , Exp )])) :+: ( C1 (' MetaCons "LetE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Dec ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "CaseE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Match ])))) :+: (( C1 (' MetaCons "DoE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Stmt ])) :+: C1 (' MetaCons "MDoE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Stmt ]))) :+: ( C1 (' MetaCons "CompE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Stmt ])) :+: C1 (' MetaCons "ArithSeqE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Range ))))) :+: ((( C1 (' MetaCons "ListE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Exp ])) :+: C1 (' MetaCons "SigE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :+: ( C1 (' MetaCons "RecConE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ FieldExp ])) :+: C1 (' MetaCons "RecUpdE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ FieldExp ])))) :+: (( C1 (' MetaCons "StaticE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "UnboundVarE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ))) :+: ( C1 (' MetaCons "LabelE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )) :+: C1 (' MetaCons "ImplicitParamVarE" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )))))))
type Rep Match
Instance details Defined in Language.Haskell.TH.Syntax type Rep Match = D1 (' MetaData "Match" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Match" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Body ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Dec ]))))
type Rep Clause
Instance details Defined in Language.Haskell.TH.Syntax type Rep Clause = D1 (' MetaData "Clause" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Clause" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Pat ]) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Body ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Dec ]))))
type Rep Pat
Instance details Defined in Language.Haskell.TH.Syntax type Rep Pat = D1 (' MetaData "Pat" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (((( C1 (' MetaCons "LitP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Lit )) :+: C1 (' MetaCons "VarP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ))) :+: ( C1 (' MetaCons "TupP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Pat ])) :+: C1 (' MetaCons "UnboxedTupP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Pat ])))) :+: (( C1 (' MetaCons "UnboxedSumP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 SumAlt ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 SumArity ))) :+: C1 (' MetaCons "ConP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Pat ]))) :+: ( C1 (' MetaCons "InfixP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ))) :+: C1 (' MetaCons "UInfixP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat )))))) :+: ((( C1 (' MetaCons "ParensP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat )) :+: C1 (' MetaCons "TildeP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ))) :+: ( C1 (' MetaCons "BangP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat )) :+: C1 (' MetaCons "AsP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat )))) :+: (( C1 (' MetaCons "WildP" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "RecP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ FieldPat ]))) :+: ( C1 (' MetaCons "ListP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Pat ])) :+: ( C1 (' MetaCons "SigP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )) :+: C1 (' MetaCons "ViewP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat )))))))
type Rep Type
Instance details Defined in Language.Haskell.TH.Syntax type Rep Type = D1 (' MetaData "Type" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (((( C1 (' MetaCons "ForallT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :+: ( C1 (' MetaCons "ForallVisT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )) :+: C1 (' MetaCons "AppT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )))) :+: ( C1 (' MetaCons "AppKindT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Kind )) :+: ( C1 (' MetaCons "SigT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Kind )) :+: C1 (' MetaCons "VarT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ))))) :+: (( C1 (' MetaCons "ConT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: ( C1 (' MetaCons "PromotedT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: C1 (' MetaCons "InfixT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))))) :+: ( C1 (' MetaCons "UInfixT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :+: ( C1 (' MetaCons "ParensT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )) :+: C1 (' MetaCons "TupleT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int )))))) :+: ((( C1 (' MetaCons "UnboxedTupleT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int )) :+: ( C1 (' MetaCons "UnboxedSumT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 SumArity )) :+: C1 (' MetaCons "ArrowT" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: ( C1 (' MetaCons "EqualityT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "ListT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PromotedTupleT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int ))))) :+: (( C1 (' MetaCons "PromotedNilT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "PromotedConsT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "StarT" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "ConstraintT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "LitT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 TyLit ))) :+: ( C1 (' MetaCons "WildCardT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ImplicitParamT" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )))))))
type Rep Dec
Instance details Defined in Language.Haskell.TH.Syntax type Rep Dec = D1 (' MetaData "Dec" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (((( C1 (' MetaCons "FunD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Clause ])) :+: ( C1 (' MetaCons "ValD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Body ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Dec ]))) :+: C1 (' MetaCons "DataD" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]))) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Kind )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Con ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ DerivClause ])))))) :+: ( C1 (' MetaCons "NewtypeD" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]))) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Kind )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Con ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ DerivClause ])))) :+: ( C1 (' MetaCons "TySynD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :+: C1 (' MetaCons "ClassD" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ FunDep ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Dec ]))))))) :+: (( C1 (' MetaCons "InstanceD" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Overlap )) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Dec ]))) :+: ( C1 (' MetaCons "SigD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )) :+: C1 (' MetaCons "KiSigD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Kind )))) :+: ( C1 (' MetaCons "ForeignD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Foreign )) :+: ( C1 (' MetaCons "InfixD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Fixity ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: C1 (' MetaCons "PragmaD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pragma )))))) :+: ((( C1 (' MetaCons "DataFamilyD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Kind )))) :+: ( C1 (' MetaCons "DataInstD" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe [ TyVarBndr ])) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Kind )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Con ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ DerivClause ])))) :+: C1 (' MetaCons "NewtypeInstD" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe [ TyVarBndr ])) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Kind )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Con ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ DerivClause ])))))) :+: ( C1 (' MetaCons "TySynInstD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 TySynEqn )) :+: ( C1 (' MetaCons "OpenTypeFamilyD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 TypeFamilyHead )) :+: C1 (' MetaCons "ClosedTypeFamilyD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 TypeFamilyHead ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TySynEqn ]))))) :+: (( C1 (' MetaCons "RoleAnnotD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Role ])) :+: ( C1 (' MetaCons "StandaloneDerivD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe DerivStrategy )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :+: C1 (' MetaCons "DefaultSigD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )))) :+: ( C1 (' MetaCons "PatSynD" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PatSynArgs )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PatSynDir ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ))) :+: ( C1 (' MetaCons "PatSynSigD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PatSynType )) :+: C1 (' MetaCons "ImplicitParamBindD" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )))))))
type Rep Name
Instance details Defined in Language.Haskell.TH.Syntax type Rep Name = D1 (' MetaData "Name" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Name" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 OccName ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 NameFlavour )))
type Rep FunDep
Instance details Defined in Language.Haskell.TH.Syntax type Rep FunDep = D1 (' MetaData "FunDep" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "FunDep" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ]) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ])))
type Rep InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax type Rep InjectivityAnn = D1 (' MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "InjectivityAnn" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ])))
type Rep Overlap
Instance details Defined in Language.Haskell.TH.Syntax type Rep Overlap = D1 (' MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "Overlappable" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "Overlapping" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "Overlaps" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "Incoherent" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep ()
Instance details Defined in GHC.Generics type Rep () = D1 (' MetaData "()" "GHC.Tuple" "ghc-prim" ' False ) ( C1 (' MetaCons "()" ' PrefixI ' False ) ( U1 :: Type -> Type ))
type Rep Value
Instance details Defined in Data.Aeson.Types.Internal type Rep Value = D1 (' MetaData "Value" "Data.Aeson.Types.Internal" "aeson-2.0.2.0-Hbc7lMoCN3S5f36Jsk6Tpd" ' False ) (( C1 (' MetaCons "Object" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Object )) :+: ( C1 (' MetaCons "Array" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Array )) :+: C1 (' MetaCons "String" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Text )))) :+: ( C1 (' MetaCons "Number" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Scientific )) :+: ( C1 (' MetaCons "Bool" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Bool )) :+: C1 (' MetaCons "Null" ' PrefixI ' False ) ( U1 :: Type -> Type ))))
type Rep Void
Instance details Defined in Data.Void type Rep Void = D1 (' MetaData "Void" "Data.Void" "base" ' False ) ( V1 :: Type -> Type )
type Rep Version
Instance details Defined in Data.Version type Rep Version = D1 (' MetaData "Version" "Data.Version" "base" ' False ) ( C1 (' MetaCons "Version" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "versionBranch") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Int ]) :*: S1 (' MetaSel (' Just "versionTags") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ String ])))
type Rep ExitCode
Instance details Defined in GHC.IO.Exception type Rep ExitCode = D1 (' MetaData "ExitCode" "GHC.IO.Exception" "base" ' False ) ( C1 (' MetaCons "ExitSuccess" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ExitFailure" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int )))
type Rep All
Instance details Defined in Data.Semigroup.Internal type Rep All = D1 (' MetaData "All" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "All" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAll") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Bool )))
type Rep Any
Instance details Defined in Data.Semigroup.Internal type Rep Any = D1 (' MetaData "Any" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Any" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAny") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Bool )))
type Rep Fixity
Instance details Defined in GHC.Generics type Rep Fixity = D1 (' MetaData "Fixity" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "Prefix" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "Infix" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Associativity ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int )))
type Rep Associativity
Instance details Defined in GHC.Generics type Rep Associativity = D1 (' MetaData "Associativity" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "LeftAssociative" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "RightAssociative" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NotAssociative" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep SourceUnpackedness
Instance details Defined in GHC.Generics type Rep SourceUnpackedness = D1 (' MetaData "SourceUnpackedness" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "NoSourceUnpackedness" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "SourceNoUnpack" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "SourceUnpack" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep SourceStrictness
Instance details Defined in GHC.Generics type Rep SourceStrictness = D1 (' MetaData "SourceStrictness" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "NoSourceStrictness" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "SourceLazy" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "SourceStrict" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep DecidedStrictness
Instance details Defined in GHC.Generics type Rep DecidedStrictness = D1 (' MetaData "DecidedStrictness" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "DecidedLazy" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "DecidedStrict" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DecidedUnpack" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep Extension
Instance details Defined in GHC.LanguageExtensions.Type type Rep Extension = D1 (' MetaData "Extension" "GHC.LanguageExtensions.Type" "ghc-boot-th-8.10.7" ' False ) (((((( C1 (' MetaCons "Cpp" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "OverlappingInstances" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "UndecidableInstances" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "IncoherentInstances" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "UndecidableSuperClasses" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "MonomorphismRestriction" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MonoPatBinds" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: (( C1 (' MetaCons "MonoLocalBinds" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "RelaxedPolyRec" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ExtendedDefaultRules" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "ForeignFunctionInterface" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "UnliftedFFITypes" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "InterruptibleFFI" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "CApiFFI" ' PrefixI ' False ) ( U1 :: Type -> Type ))))) :+: ((( C1 (' MetaCons "GHCForeignImportPrim" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "JavaScriptFFI" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ParallelArrays" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "Arrows" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TemplateHaskell" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "TemplateHaskellQuotes" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "QuasiQuotes" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "ImplicitParams" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ImplicitPrelude" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "ScopedTypeVariables" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "AllowAmbiguousTypes" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "UnboxedTuples" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "UnboxedSums" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "UnliftedNewtypes" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "BangPatterns" ' PrefixI ' False ) ( U1 :: Type -> Type )))))) :+: (((( C1 (' MetaCons "TypeFamilies" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "TypeFamilyDependencies" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TypeInType" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "OverloadedStrings" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "OverloadedLists" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "NumDecimals" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DisambiguateRecordFields" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "RecordWildCards" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "RecordPuns" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "ViewPatterns" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "GADTs" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "GADTSyntax" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NPlusKPatterns" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "DoAndIfThenElse" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "BlockArguments" ' PrefixI ' False ) ( U1 :: Type -> Type ))))) :+: ((( C1 (' MetaCons "RebindableSyntax" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "ConstraintKinds" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PolyKinds" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "DataKinds" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "InstanceSigs" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "ApplicativeDo" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "StandaloneDeriving" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "DeriveDataTypeable" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "AutoDeriveTypeable" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "DeriveFunctor" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DeriveTraversable" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "DeriveFoldable" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DeriveGeneric" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "DefaultSignatures" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DeriveAnyClass" ' PrefixI ' False ) ( U1 :: Type -> Type ))))))) :+: ((((( C1 (' MetaCons "DeriveLift" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "DerivingStrategies" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DerivingVia" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "TypeSynonymInstances" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "FlexibleContexts" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "FlexibleInstances" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ConstrainedClassMethods" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "MultiParamTypeClasses" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NullaryTypeClasses" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "FunctionalDependencies" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "UnicodeSyntax" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "ExistentialQuantification" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MagicHash" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "EmptyDataDecls" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "KindSignatures" ' PrefixI ' False ) ( U1 :: Type -> Type ))))) :+: ((( C1 (' MetaCons "RoleAnnotations" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "ParallelListComp" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TransformListComp" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "MonadComprehensions" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "GeneralizedNewtypeDeriving" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "RecursiveDo" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PostfixOperators" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "TupleSections" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PatternGuards" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "LiberalTypeSynonyms" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "RankNTypes" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "ImpredicativeTypes" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TypeOperators" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "ExplicitNamespaces" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PackageImports" ' PrefixI ' False ) ( U1 :: Type -> Type )))))) :+: (((( C1 (' MetaCons "ExplicitForAll" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "AlternativeLayoutRule" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "AlternativeLayoutRuleTransitional" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "DatatypeContexts" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NondecreasingIndentation" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "RelaxedLayout" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TraditionalRecordSyntax" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "LambdaCase" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MultiWayIf" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "BinaryLiterals" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NegativeLiterals" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "HexFloatLiterals" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DuplicateRecordFields" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "OverloadedLabels" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "EmptyCase" ' PrefixI ' False ) ( U1 :: Type -> Type ))))) :+: ((( C1 (' MetaCons "PatternSynonyms" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "PartialTypeSignatures" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NamedWildCards" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "StaticPointers" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TypeApplications" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "Strict" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "StrictData" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "MonadFailDesugaring" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "EmptyDataDeriving" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "NumericUnderscores" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "QuantifiedConstraints" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "StarIsType" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ImportQualifiedPost" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "CUSKs" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "StandaloneKindSignatures" ' PrefixI ' False ) ( U1 :: Type -> Type ))))))))
type Rep ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type type Rep ForeignSrcLang = D1 (' MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-8.10.7" ' False ) (( C1 (' MetaCons "LangC" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "LangCxx" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "LangObjc" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: ( C1 (' MetaCons "LangObjcxx" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "LangAsm" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "RawObject" ' PrefixI ' False ) ( U1 :: Type -> Type ))))
type Rep PrimType
Instance details Defined in GHC.Exts.Heap.Closures type Rep PrimType = D1 (' MetaData "PrimType" "GHC.Exts.Heap.Closures" "ghc-heap-8.10.7-IUP7BK823zx9GcxXynNXv1" ' False ) (( C1 (' MetaCons "PInt" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "PWord" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PInt64" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "PWord64" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PAddr" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "PFloat" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PDouble" ' PrefixI ' False ) ( U1 :: Type -> Type ))))
type Rep StgInfoTable
Instance details Defined in GHC.Exts.Heap.InfoTable.Types type Rep StgInfoTable = D1 (' MetaData "StgInfoTable" "GHC.Exts.Heap.InfoTable.Types" "ghc-heap-8.10.7-IUP7BK823zx9GcxXynNXv1" ' False ) ( C1 (' MetaCons "StgInfoTable" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "entry") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe EntryFunPtr )) :: ( S1 (' MetaSel (' Just "ptrs") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 HalfWord ) :: S1 (' MetaSel (' Just "nptrs") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 HalfWord ))) :: ( S1 (' MetaSel (' Just "tipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ClosureType ) :: ( S1 (' MetaSel (' Just "srtlen") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 HalfWord ) :*: S1 (' MetaSel (' Just "code") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe ItblCodes ))))))
type Rep ClosureType
Instance details Defined in GHC.Exts.Heap.ClosureTypes type Rep ClosureType = D1 (' MetaData "ClosureType" "GHC.Exts.Heap.ClosureTypes" "ghc-heap-8.10.7-IUP7BK823zx9GcxXynNXv1" ' False ) (((((( C1 (' MetaCons "INVALID_OBJECT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "CONSTR" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "CONSTR_1_0" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "CONSTR_0_1" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "CONSTR_2_0" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "CONSTR_1_1" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "CONSTR_0_2" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "CONSTR_NOCAF" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "FUN" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "FUN_1_0" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "FUN_0_1" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "FUN_2_0" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "FUN_1_1" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "FUN_0_2" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "FUN_STATIC" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "THUNK" ' PrefixI ' False ) ( U1 :: Type -> Type ))))) :+: (((( C1 (' MetaCons "THUNK_1_0" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "THUNK_0_1" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "THUNK_2_0" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "THUNK_1_1" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "THUNK_0_2" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "THUNK_STATIC" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "THUNK_SELECTOR" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "BCO" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "AP" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "PAP" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "AP_STACK" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "IND" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "IND_STATIC" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "RET_BCO" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "RET_SMALL" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "RET_BIG" ' PrefixI ' False ) ( U1 :: Type -> Type )))))) :+: ((((( C1 (' MetaCons "RET_FUN" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "UPDATE_FRAME" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "CATCH_FRAME" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "UNDERFLOW_FRAME" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "STOP_FRAME" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "BLOCKING_QUEUE" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "BLACKHOLE" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MVAR_CLEAN" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "MVAR_DIRTY" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TVAR" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "ARR_WORDS" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MUT_ARR_PTRS_CLEAN" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "MUT_ARR_PTRS_DIRTY" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MUT_ARR_PTRS_FROZEN_DIRTY" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "MUT_ARR_PTRS_FROZEN_CLEAN" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MUT_VAR_CLEAN" ' PrefixI ' False ) ( U1 :: Type -> Type ))))) :+: (((( C1 (' MetaCons "MUT_VAR_DIRTY" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "WEAK" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "PRIM" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "MUT_PRIM" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "TSO" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "STACK" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "TREC_CHUNK" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ATOMICALLY_FRAME" ' PrefixI ' False ) ( U1 :: Type -> Type )))) :+: ((( C1 (' MetaCons "CATCH_RETRY_FRAME" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "CATCH_STM_FRAME" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "WHITEHOLE" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "SMALL_MUT_ARR_PTRS_CLEAN" ' PrefixI ' False ) ( U1 :: Type -> Type ))) :+: (( C1 (' MetaCons "SMALL_MUT_ARR_PTRS_DIRTY" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "SMALL_MUT_ARR_PTRS_FROZEN_DIRTY" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "SMALL_MUT_ARR_PTRS_FROZEN_CLEAN" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "COMPACT_NFDATA" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "N_CLOSURE_TYPES" ' PrefixI ' False ) ( U1 :: Type -> Type ))))))))
type Rep Doc
Instance details Defined in Text.PrettyPrint.HughesPJ type Rep Doc = D1 (' MetaData "Doc" "Text.PrettyPrint.HughesPJ" "pretty-1.1.3.6" ' True ) ( C1 (' MetaCons "Doc" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc ()))))
type Rep TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ type Rep TextDetails = D1 (' MetaData "TextDetails" "Text.PrettyPrint.Annotated.HughesPJ" "pretty-1.1.3.6" ' False ) ( C1 (' MetaCons "Chr" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' SourceUnpack ' SourceStrict ' DecidedUnpack ) ( Rec0 Char )) :+: ( C1 (' MetaCons "Str" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )) :+: C1 (' MetaCons "PStr" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ))))
type Rep Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ type Rep Style = D1 (' MetaData "Style" "Text.PrettyPrint.Annotated.HughesPJ" "pretty-1.1.3.6" ' False ) ( C1 (' MetaCons "Style" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "mode") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Mode ) :: ( S1 (' MetaSel (' Just "lineLength") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int ) :: S1 (' MetaSel (' Just "ribbonsPerLine") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Float ))))
type Rep Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ type Rep Mode = D1 (' MetaData "Mode" "Text.PrettyPrint.Annotated.HughesPJ" "pretty-1.1.3.6" ' False ) (( C1 (' MetaCons "PageMode" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ZigZagMode" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "LeftMode" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "OneLineMode" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep ModName
Instance details Defined in Language.Haskell.TH.Syntax type Rep ModName = D1 (' MetaData "ModName" "Language.Haskell.TH.Syntax" "template-haskell" ' True ) ( C1 (' MetaCons "ModName" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )))
type Rep PkgName
Instance details Defined in Language.Haskell.TH.Syntax type Rep PkgName = D1 (' MetaData "PkgName" "Language.Haskell.TH.Syntax" "template-haskell" ' True ) ( C1 (' MetaCons "PkgName" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )))
type Rep Module
Instance details Defined in Language.Haskell.TH.Syntax type Rep Module = D1 (' MetaData "Module" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Module" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PkgName ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ModName )))
type Rep OccName
Instance details Defined in Language.Haskell.TH.Syntax type Rep OccName = D1 (' MetaData "OccName" "Language.Haskell.TH.Syntax" "template-haskell" ' True ) ( C1 (' MetaCons "OccName" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )))
type Rep NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax type Rep NameFlavour = D1 (' MetaData "NameFlavour" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "NameS" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NameQ" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ModName ))) :+: ( C1 (' MetaCons "NameU" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Uniq )) :+: ( C1 (' MetaCons "NameL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Uniq )) :+: C1 (' MetaCons "NameG" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 NameSpace ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PkgName ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ModName ))))))
type Rep NameSpace
Instance details Defined in Language.Haskell.TH.Syntax type Rep NameSpace = D1 (' MetaData "NameSpace" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "VarName" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "DataName" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "TcClsName" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep Loc
Instance details Defined in Language.Haskell.TH.Syntax type Rep Loc = D1 (' MetaData "Loc" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Loc" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "loc_filename") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ) :: S1 (' MetaSel (' Just "loc_package") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )) :: ( S1 (' MetaSel (' Just "loc_module") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ) :: ( S1 (' MetaSel (' Just "loc_start") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 CharPos ) :: S1 (' MetaSel (' Just "loc_end") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 CharPos )))))
type Rep Info
Instance details Defined in Language.Haskell.TH.Syntax type Rep Info = D1 (' MetaData "Info" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ((( C1 (' MetaCons "ClassI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Dec ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ InstanceDec ])) :+: C1 (' MetaCons "ClassOpI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ParentName )))) :+: ( C1 (' MetaCons "TyConI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Dec )) :+: C1 (' MetaCons "FamilyI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Dec ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ InstanceDec ])))) :+: (( C1 (' MetaCons "PrimTyConI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Arity ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Unlifted ))) :+: C1 (' MetaCons "DataConI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ParentName )))) :+: ( C1 (' MetaCons "PatSynI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PatSynType )) :+: ( C1 (' MetaCons "VarI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Dec )))) :+: C1 (' MetaCons "TyVarI" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))))))
type Rep ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax type Rep ModuleInfo = D1 (' MetaData "ModuleInfo" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "ModuleInfo" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Module ])))
type Rep Fixity
Instance details Defined in Language.Haskell.TH.Syntax type Rep Fixity = D1 (' MetaData "Fixity" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Fixity" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 FixityDirection )))
type Rep FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax type Rep FixityDirection = D1 (' MetaData "FixityDirection" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "InfixL" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "InfixR" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "InfixN" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep Lit
Instance details Defined in Language.Haskell.TH.Syntax type Rep Lit = D1 (' MetaData "Lit" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ((( C1 (' MetaCons "CharL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Char )) :+: C1 (' MetaCons "StringL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ))) :+: ( C1 (' MetaCons "IntegerL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Integer )) :+: ( C1 (' MetaCons "RationalL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Rational )) :+: C1 (' MetaCons "IntPrimL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Integer ))))) :+: (( C1 (' MetaCons "WordPrimL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Integer )) :+: ( C1 (' MetaCons "FloatPrimL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Rational )) :+: C1 (' MetaCons "DoublePrimL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Rational )))) :+: ( C1 (' MetaCons "StringPrimL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Word8 ])) :+: ( C1 (' MetaCons "BytesPrimL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Bytes )) :+: C1 (' MetaCons "CharPrimL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Char ))))))
type Rep Bytes
Instance details Defined in Language.Haskell.TH.Syntax type Rep Bytes = D1 (' MetaData "Bytes" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Bytes" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "bytesPtr") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( ForeignPtr Word8 )) :: ( S1 (' MetaSel (' Just "bytesOffset") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Word ) :: S1 (' MetaSel (' Just "bytesSize") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Word ))))
type Rep Body
Instance details Defined in Language.Haskell.TH.Syntax type Rep Body = D1 (' MetaData "Body" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "GuardedB" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [( Guard , Exp )])) :+: C1 (' MetaCons "NormalB" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )))
type Rep Guard
Instance details Defined in Language.Haskell.TH.Syntax type Rep Guard = D1 (' MetaData "Guard" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "NormalG" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "PatG" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Stmt ])))
type Rep Stmt
Instance details Defined in Language.Haskell.TH.Syntax type Rep Stmt = D1 (' MetaData "Stmt" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "BindS" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Pat ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "LetS" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Dec ]))) :+: ( C1 (' MetaCons "NoBindS" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: ( C1 (' MetaCons "ParS" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [[ Stmt ]])) :+: C1 (' MetaCons "RecS" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Stmt ])))))
type Rep Range
Instance details Defined in Language.Haskell.TH.Syntax type Rep Range = D1 (' MetaData "Range" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "FromR" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "FromThenR" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ))) :+: ( C1 (' MetaCons "FromToR" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )) :+: C1 (' MetaCons "FromThenToR" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp )))))
type Rep DerivClause
Instance details Defined in Language.Haskell.TH.Syntax type Rep DerivClause = D1 (' MetaData "DerivClause" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "DerivClause" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe DerivStrategy )) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt )))
type Rep DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax type Rep DerivStrategy = D1 (' MetaData "DerivStrategy" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "StockStrategy" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "AnyclassStrategy" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "NewtypeStrategy" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ViaStrategy" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))))
type Rep TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax type Rep TypeFamilyHead = D1 (' MetaData "TypeFamilyHead" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "TypeFamilyHead" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ])) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 FamilyResultSig ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe InjectivityAnn )))))
type Rep TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax type Rep TySynEqn = D1 (' MetaData "TySynEqn" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "TySynEqn" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe [ TyVarBndr ])) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))))
type Rep Foreign
Instance details Defined in Language.Haskell.TH.Syntax type Rep Foreign = D1 (' MetaData "Foreign" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "ImportF" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Callconv ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Safety )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )))) :+: C1 (' MetaCons "ExportF" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Callconv ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))))
type Rep Callconv
Instance details Defined in Language.Haskell.TH.Syntax type Rep Callconv = D1 (' MetaData "Callconv" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "CCall" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "StdCall" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "CApi" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "Prim" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "JavaScript" ' PrefixI ' False ) ( U1 :: Type -> Type ))))
type Rep Safety
Instance details Defined in Language.Haskell.TH.Syntax type Rep Safety = D1 (' MetaData "Safety" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Unsafe" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "Safe" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "Interruptible" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep Pragma
Instance details Defined in Language.Haskell.TH.Syntax type Rep Pragma = D1 (' MetaData "Pragma" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "InlineP" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Inline )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 RuleMatch ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Phases ))) :+: ( C1 (' MetaCons "SpecialiseP" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Inline )) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Phases ))) :+: C1 (' MetaCons "SpecialiseInstP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )))) :+: (( C1 (' MetaCons "RuleP" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe [ TyVarBndr ])) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ RuleBndr ]))) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Phases )))) :+: C1 (' MetaCons "AnnP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 AnnTarget ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Exp ))) :+: ( C1 (' MetaCons "LineP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )) :+: C1 (' MetaCons "CompleteP" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe Name ))))))
type Rep Inline
Instance details Defined in Language.Haskell.TH.Syntax type Rep Inline = D1 (' MetaData "Inline" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "NoInline" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "Inline" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "Inlinable" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax type Rep RuleMatch = D1 (' MetaData "RuleMatch" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "ConLike" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "FunLike" ' PrefixI ' False ) ( U1 :: Type -> Type ))
type Rep Phases
Instance details Defined in Language.Haskell.TH.Syntax type Rep Phases = D1 (' MetaData "Phases" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "AllPhases" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "FromPhase" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int )) :+: C1 (' MetaCons "BeforePhase" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int ))))
type Rep RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax type Rep RuleBndr = D1 (' MetaData "RuleBndr" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "RuleVar" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: C1 (' MetaCons "TypedRuleVar" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type )))
type Rep AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax type Rep AnnTarget = D1 (' MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "ModuleAnnotation" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "TypeAnnotation" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: C1 (' MetaCons "ValueAnnotation" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ))))
type Rep SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax type Rep SourceUnpackedness = D1 (' MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "NoSourceUnpackedness" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "SourceNoUnpack" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "SourceUnpack" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax type Rep SourceStrictness = D1 (' MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "NoSourceStrictness" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "SourceLazy" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "SourceStrict" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax type Rep DecidedStrictness = D1 (' MetaData "DecidedStrictness" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "DecidedLazy" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "DecidedStrict" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "DecidedUnpack" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep Con
Instance details Defined in Language.Haskell.TH.Syntax type Rep Con = D1 (' MetaData "Con" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "NormalC" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ BangType ])) :+: ( C1 (' MetaCons "RecC" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ VarBangType ])) :+: C1 (' MetaCons "InfixC" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 BangType ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 BangType ))))) :+: ( C1 (' MetaCons "ForallC" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ TyVarBndr ]) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Cxt ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Con ))) :+: ( C1 (' MetaCons "GadtC" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ]) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ BangType ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))) :+: C1 (' MetaCons "RecGadtC" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ]) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ VarBangType ]) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Type ))))))
type Rep Bang
Instance details Defined in Language.Haskell.TH.Syntax type Rep Bang = D1 (' MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Bang" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 SourceUnpackedness ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 SourceStrictness )))
type Rep PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax type Rep PatSynDir = D1 (' MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "Unidir" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "ImplBidir" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ExplBidir" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Clause ]))))
type Rep PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax type Rep PatSynArgs = D1 (' MetaData "PatSynArgs" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "PrefixPatSyn" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ])) :+: ( C1 (' MetaCons "InfixPatSyn" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: C1 (' MetaCons "RecordPatSyn" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Name ]))))
type Rep TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax type Rep TyVarBndr = D1 (' MetaData "TyVarBndr" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "PlainTV" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )) :+: C1 (' MetaCons "KindedTV" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Kind )))
type Rep FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax type Rep FamilyResultSig = D1 (' MetaData "FamilyResultSig" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "NoSig" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "KindSig" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Kind )) :+: C1 (' MetaCons "TyVarSig" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 TyVarBndr ))))
type Rep TyLit
Instance details Defined in Language.Haskell.TH.Syntax type Rep TyLit = D1 (' MetaData "TyLit" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "NumTyLit" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Integer )) :+: C1 (' MetaCons "StrTyLit" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 String )))
type Rep Role
Instance details Defined in Language.Haskell.TH.Syntax type Rep Role = D1 (' MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) (( C1 (' MetaCons "NominalR" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "RepresentationalR" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "PhantomR" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "InferR" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type Rep AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax type Rep AnnLookup = D1 (' MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "template-haskell" ' False ) ( C1 (' MetaCons "AnnLookupModule" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Module )) :+: C1 (' MetaCons "AnnLookupName" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Name )))
type Rep [a]
Instance details Defined in GHC.Generics type Rep [a] = D1 (' MetaData "[]" "GHC.Types" "ghc-prim" ' False ) ( C1 (' MetaCons "[]" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons ":" (' InfixI ' LeftAssociative 9) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [a])))
type Rep ( Maybe a)
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)))
type Rep ( Par1 p)
Instance details Defined in GHC.Generics type Rep ( Par1 p) = D1 (' MetaData "Par1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "Par1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unPar1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 p)))
type Rep ( Solo a)
Instance details Defined in Data.Tuple.Solo type Rep ( Solo a) = D1 (' MetaData "Solo" "Data.Tuple.Solo" "OneTuple-0.3.1-2dHxJgLo5x9Lj2QijnVAuZ" ' False ) ( C1 (' MetaCons "Solo" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getSolo") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Complex a)
Instance details Defined in Data.Complex type Rep ( Complex a) = D1 (' MetaData "Complex" "Data.Complex" "base" ' False ) ( C1 (' MetaCons ":+" (' InfixI ' NotAssociative 6) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a)))
type Rep ( Min a)
Instance details Defined in Data.Semigroup type Rep ( Min a) = D1 (' MetaData "Min" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "Min" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getMin") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Max a)
Instance details Defined in Data.Semigroup type Rep ( Max a) = D1 (' MetaData "Max" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "Max" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getMax") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( First a)
Instance details Defined in Data.Semigroup type Rep ( First a) = D1 (' MetaData "First" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "First" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getFirst") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Last a)
Instance details Defined in Data.Semigroup type Rep ( Last a) = D1 (' MetaData "Last" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "Last" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getLast") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( WrappedMonoid m)
Instance details Defined in Data.Semigroup type Rep ( WrappedMonoid m) = D1 (' MetaData "WrappedMonoid" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "WrapMonoid" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unwrapMonoid") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 m)))
type Rep ( Option a)
Instance details Defined in Data.Semigroup type Rep ( Option a) = D1 (' MetaData "Option" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "Option" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getOption") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe a))))
type Rep ( ZipList a)
Instance details Defined in Control.Applicative type Rep ( ZipList a) = D1 (' MetaData "ZipList" "Control.Applicative" "base" ' True ) ( C1 (' MetaCons "ZipList" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getZipList") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [a])))
type Rep ( Identity a)
Instance details Defined in Data.Functor.Identity type Rep ( Identity a) = D1 (' MetaData "Identity" "Data.Functor.Identity" "base" ' True ) ( C1 (' MetaCons "Identity" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "runIdentity") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( First a)
Instance details Defined in Data.Monoid type Rep ( First a) = D1 (' MetaData "First" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "First" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getFirst") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe a))))
type Rep ( Last a)
Instance details Defined in Data.Monoid type Rep ( Last a) = D1 (' MetaData "Last" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "Last" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getLast") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe a))))
type Rep ( Dual a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Dual a) = D1 (' MetaData "Dual" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Dual" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getDual") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Endo a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Endo a) = D1 (' MetaData "Endo" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Endo" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "appEndo") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (a -> a))))
type Rep ( Sum a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Sum a) = D1 (' MetaData "Sum" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Sum" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getSum") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Product a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Product a) = D1 (' MetaData "Product" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Product" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getProduct") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Down a)
Instance details Defined in GHC.Generics type Rep ( Down a) = D1 (' MetaData "Down" "Data.Ord" "base" ' True ) ( C1 (' MetaCons "Down" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getDown") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( NonEmpty a)
Instance details Defined in GHC.Generics type Rep ( NonEmpty a) = D1 (' MetaData "NonEmpty" "GHC.Base" "base" ' False ) ( C1 (' MetaCons ":\|" (' InfixI ' LeftAssociative 9) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [a])))
type Rep ( Tree a)
Instance details Defined in Data.Tree type Rep ( Tree a) = D1 (' MetaData "Tree" "Data.Tree" "containers-0.6.5.1-EiES0HFUZ8PBGNrpVjoYRF" ' False ) ( C1 (' MetaCons "Node" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "rootLabel") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Just "subForest") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [ Tree a])))
type Rep ( FingerTree a)
Instance details Defined in Data.Sequence.Internal type Rep ( FingerTree a) = D1 (' MetaData "FingerTree" "Data.Sequence.Internal" "containers-0.6.5.1-EiES0HFUZ8PBGNrpVjoYRF" ' False ) ( C1 (' MetaCons "EmptyT" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "Single" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :+: C1 (' MetaCons "Deep" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' SourceUnpack ' SourceStrict ' DecidedUnpack ) ( Rec0 Int ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( Digit a))) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( FingerTree ( Node a))) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( Digit a))))))
type Rep ( Digit a)
Instance details Defined in Data.Sequence.Internal type Rep ( Digit a) = D1 (' MetaData "Digit" "Data.Sequence.Internal" "containers-0.6.5.1-EiES0HFUZ8PBGNrpVjoYRF" ' False ) (( C1 (' MetaCons "One" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :+: C1 (' MetaCons "Two" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a))) :+: ( C1 (' MetaCons "Three" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a))) :+: C1 (' MetaCons "Four" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))))
type Rep ( Node a)
Instance details Defined in Data.Sequence.Internal type Rep ( Node a) = D1 (' MetaData "Node" "Data.Sequence.Internal" "containers-0.6.5.1-EiES0HFUZ8PBGNrpVjoYRF" ' False ) ( C1 (' MetaCons "Node2" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' SourceUnpack ' SourceStrict ' DecidedUnpack ) ( Rec0 Int ) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a))) :+: C1 (' MetaCons "Node3" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' SourceUnpack ' SourceStrict ' DecidedUnpack ) ( Rec0 Int ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a))))
type Rep ( Elem a)
Instance details Defined in Data.Sequence.Internal type Rep ( Elem a) = D1 (' MetaData "Elem" "Data.Sequence.Internal" "containers-0.6.5.1-EiES0HFUZ8PBGNrpVjoYRF" ' True ) ( C1 (' MetaCons "Elem" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getElem") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( ViewL a)
Instance details Defined in Data.Sequence.Internal type Rep ( ViewL a) = D1 (' MetaData "ViewL" "Data.Sequence.Internal" "containers-0.6.5.1-EiES0HFUZ8PBGNrpVjoYRF" ' False ) ( C1 (' MetaCons "EmptyL" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons ":<" (' InfixI ' RightAssociative 5) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Seq a))))
type Rep ( ViewR a)
Instance details Defined in Data.Sequence.Internal type Rep ( ViewR a) = D1 (' MetaData "ViewR" "Data.Sequence.Internal" "containers-0.6.5.1-EiES0HFUZ8PBGNrpVjoYRF" ' False ) ( C1 (' MetaCons "EmptyR" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons ":>" (' InfixI ' LeftAssociative 5) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Seq a)) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Fix f)
Instance details Defined in Data.Fix type Rep ( Fix f) = D1 (' MetaData "Fix" "Data.Fix" "data-fix-0.3.2-LpD4EKXxVVUJR8w9NGWPdd" ' True ) ( C1 (' MetaCons "Fix" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unFix") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f ( Fix f)))))
type Rep ( GenClosure b)
Instance details Defined in GHC.Exts.Heap.Closures type Rep ( GenClosure b) = D1 (' MetaData "GenClosure" "GHC.Exts.Heap.Closures" "ghc-heap-8.10.7-IUP7BK823zx9GcxXynNXv1" ' False ) (((( C1 (' MetaCons "ConstrClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "ptrArgs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]) :: S1 (' MetaSel (' Just "dataArgs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [ Word ]))) :: ( S1 (' MetaSel (' Just "pkg") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 String ) :: ( S1 (' MetaSel (' Just "modl") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 String ) :: S1 (' MetaSel (' Just "name") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 String )))) :+: ( C1 (' MetaCons "FunClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "ptrArgs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]) :: S1 (' MetaSel (' Just "dataArgs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [ Word ]))) :+: C1 (' MetaCons "ThunkClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "ptrArgs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]) :: S1 (' MetaSel (' Just "dataArgs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [ Word ]))))) :+: ( C1 (' MetaCons "SelectorClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "selectee") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)) :+: ( C1 (' MetaCons "PAPClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "arity") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 HalfWord )) :: ( S1 (' MetaSel (' Just "n_args") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 HalfWord ) :: ( S1 (' MetaSel (' Just "fun") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "payload") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b])))) :+: C1 (' MetaCons "APClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "arity") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 HalfWord )) :: ( S1 (' MetaSel (' Just "n_args") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 HalfWord ) :: ( S1 (' MetaSel (' Just "fun") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "payload") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]))))))) :+: (( C1 (' MetaCons "APStackClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "fun") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "payload") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]))) :+: ( C1 (' MetaCons "IndClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "indirectee") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)) :+: C1 (' MetaCons "BCOClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "instrs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "literals") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b))) :: (( S1 (' MetaSel (' Just "bcoptrs") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "arity") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 HalfWord )) :: ( S1 (' MetaSel (' Just "size") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 HalfWord ) :: S1 (' MetaSel (' Just "bitmap") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [ Word ])))))) :+: (( C1 (' MetaCons "BlackholeClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "indirectee") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)) :+: C1 (' MetaCons "ArrWordsClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "bytes") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Word ) :: S1 (' MetaSel (' Just "arrWords") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [ Word ])))) :+: ( C1 (' MetaCons "MutArrClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "mccPtrs") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Word )) :: ( S1 (' MetaSel (' Just "mccSize") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Word ) :: S1 (' MetaSel (' Just "mccPayload") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]))) :+: C1 (' MetaCons "SmallMutArrClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "mccPtrs") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Word ) :: S1 (' MetaSel (' Just "mccPayload") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]))))))) :+: ((( C1 (' MetaCons "MVarClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "queueHead") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)) :: ( S1 (' MetaSel (' Just "queueTail") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "value") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b))) :+: ( C1 (' MetaCons "MutVarClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "var") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)) :+: C1 (' MetaCons "BlockingQueueClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: S1 (' MetaSel (' Just "link") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)) :: ( S1 (' MetaSel (' Just "blackHole") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: ( S1 (' MetaSel (' Just "owner") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "queue") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)))))) :+: ( C1 (' MetaCons "WeakClosure" ' PrefixI ' True ) (( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "cfinalizers") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "key") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b))) :: ( S1 (' MetaSel (' Just "value") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: ( S1 (' MetaSel (' Just "finalizer") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b) :: S1 (' MetaSel (' Just "link") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)))) :+: ( C1 (' MetaCons "IntClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "ptipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PrimType ) :: S1 (' MetaSel (' Just "intVal") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Int )) :+: C1 (' MetaCons "WordClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "ptipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PrimType ) :: S1 (' MetaSel (' Just "wordVal") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Word ))))) :+: (( C1 (' MetaCons "Int64Closure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "ptipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PrimType ) :: S1 (' MetaSel (' Just "int64Val") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Int64 )) :+: ( C1 (' MetaCons "Word64Closure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "ptipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PrimType ) :: S1 (' MetaSel (' Just "word64Val") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Word64 )) :+: C1 (' MetaCons "AddrClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "ptipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PrimType ) :: S1 (' MetaSel (' Just "addrVal") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Int )))) :+: (( C1 (' MetaCons "FloatClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "ptipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PrimType ) :: S1 (' MetaSel (' Just "floatVal") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Float )) :+: C1 (' MetaCons "DoubleClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "ptipe") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PrimType ) :: S1 (' MetaSel (' Just "doubleVal") ' NoSourceUnpackedness ' SourceStrict ' DecidedUnpack ) ( Rec0 Double ))) :+: ( C1 (' MetaCons "OtherClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable ) :: ( S1 (' MetaSel (' Just "hvalues") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [b]) :*: S1 (' MetaSel (' Just "rawWords") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 [ Word ]))) :+: C1 (' MetaCons "UnsupportedClosure" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "info") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 StgInfoTable )))))))
type Rep ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ type Rep ( Doc a) = D1 (' MetaData "Doc" "Text.PrettyPrint.Annotated.HughesPJ" "pretty-1.1.3.6" ' False ) ((( C1 (' MetaCons "Empty" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NilAbove" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a)))) :+: ( C1 (' MetaCons "TextBeside" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( AnnotDetails a)) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a))) :+: C1 (' MetaCons "Nest" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' SourceUnpack ' SourceStrict ' DecidedUnpack ) ( Rec0 Int ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a))))) :+: (( C1 (' MetaCons "Union" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a)) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a))) :+: C1 (' MetaCons "NoDoc" ' PrefixI ' False ) ( U1 :: Type -> Type )) :+: ( C1 (' MetaCons "Beside" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a)) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Bool ) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a)))) :+: C1 (' MetaCons "Above" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a)) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Bool ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Doc a)))))))
type Rep ( Maybe a)
Instance details Defined in Data.Strict.Maybe type Rep ( Maybe a) = D1 (' MetaData "Maybe" "Data.Strict.Maybe" "strict-0.4.0.1-AAOFHkm4mgeKztrEI4BKIe" ' False ) ( C1 (' MetaCons "Nothing" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "Just" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a)))
type Rep ( Either a b)
Instance details Defined in GHC.Generics type Rep ( Either a b) = D1 (' MetaData "Either" "Data.Either" "base" ' False ) ( C1 (' MetaCons "Left" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :+: C1 (' MetaCons "Right" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)))
type Rep ( V1 p)
Instance details Defined in GHC.Generics type Rep ( V1 p) = D1 (' MetaData "V1" "GHC.Generics" "base" ' False ) ( V1 :: Type -> Type )
type Rep ( U1 p)
Instance details Defined in GHC.Generics type Rep ( U1 p) = D1 (' MetaData "U1" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "U1" ' PrefixI ' False ) ( U1 :: Type -> Type ))
type Rep (a, b)
Instance details Defined in GHC.Generics type Rep (a, b) = D1 (' MetaData "(,)" "GHC.Tuple" "ghc-prim" ' False ) ( C1 (' MetaCons "(,)" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)))
type Rep ( Arg a b)
Instance details Defined in Data.Semigroup type Rep ( Arg a b) = D1 (' MetaData "Arg" "Data.Semigroup" "base" ' False ) ( C1 (' MetaCons "Arg" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)))
type Rep ( WrappedMonad m a)
Instance details Defined in Control.Applicative type Rep ( WrappedMonad m a) = D1 (' MetaData "WrappedMonad" "Control.Applicative" "base" ' True ) ( C1 (' MetaCons "WrapMonad" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unwrapMonad") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (m a))))
type Rep ( Proxy t)
Instance details Defined in GHC.Generics type Rep ( Proxy t) = D1 (' MetaData "Proxy" "Data.Proxy" "base" ' False ) ( C1 (' MetaCons "Proxy" ' PrefixI ' False ) ( U1 :: Type -> Type ))
type Rep ( These a b)
Instance details Defined in Data.These type Rep ( These a b) = D1 (' MetaData "These" "Data.These" "these-1.1.1.1-GeR95OLAr5rCXHhUN7z1Qo" ' False ) ( C1 (' MetaCons "This" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)) :+: ( C1 (' MetaCons "That" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)) :+: C1 (' MetaCons "These" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b))))
type Rep ( Pair a b)
Instance details Defined in Data.Strict.Tuple type Rep ( Pair a b) = D1 (' MetaData "Pair" "Data.Strict.Tuple" "strict-0.4.0.1-AAOFHkm4mgeKztrEI4BKIe" ' False ) ( C1 (' MetaCons ":!:" (' InfixI ' NotAssociative 2) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)))
type Rep ( These a b)
Instance details Defined in Data.Strict.These type Rep ( These a b) = D1 (' MetaData "These" "Data.Strict.These" "strict-0.4.0.1-AAOFHkm4mgeKztrEI4BKIe" ' False ) ( C1 (' MetaCons "This" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a)) :+: ( C1 (' MetaCons "That" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)) :+: C1 (' MetaCons "These" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b))))
type Rep ( Either a b)
Instance details Defined in Data.Strict.Either type Rep ( Either a b) = D1 (' MetaData "Either" "Data.Strict.Either" "strict-0.4.0.1-AAOFHkm4mgeKztrEI4BKIe" ' False ) ( C1 (' MetaCons "Left" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a)) :+: C1 (' MetaCons "Right" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 b)))
type Rep ( Rec1 f p)
Instance details Defined in GHC.Generics type Rep ( Rec1 f p) = D1 (' MetaData "Rec1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "Rec1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unRec1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f p))))
type Rep ( URec Word p)
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 )))
type Rep ( URec Int p)
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 )))
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 )))
type Rep ( URec Double p)
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 )))
type Rep ( URec Char p)
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 )))
type Rep ( URec ( Ptr ()) p)
Instance details Defined in GHC.Generics type Rep ( URec ( Ptr ()) p) = D1 (' MetaData "URec" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "UAddr" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "uAddr#") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( UAddr :: Type -> Type )))
type Rep (a, b, c)
Instance details Defined in GHC.Generics type Rep (a, b, c) = D1 (' MetaData "(,,)" "GHC.Tuple" "ghc-prim" ' False ) ( C1 (' MetaCons "(,,)" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c))))
type Rep ( WrappedArrow a b c)
Instance details Defined in Control.Applicative type Rep ( WrappedArrow a b c) = D1 (' MetaData "WrappedArrow" "Control.Applicative" "base" ' True ) ( C1 (' MetaCons "WrapArrow" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unwrapArrow") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (a b c))))
type Rep ( Kleisli m a b)
Instance details Defined in Control.Arrow type Rep ( Kleisli m a b) = D1 (' MetaData "Kleisli" "Control.Arrow" "base" ' True ) ( C1 (' MetaCons "Kleisli" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "runKleisli") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (a -> m b))))
type Rep ( Const a b)
Instance details Defined in Data.Functor.Const type Rep ( Const a b) = D1 (' MetaData "Const" "Data.Functor.Const" "base" ' True ) ( C1 (' MetaCons "Const" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getConst") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
type Rep ( Ap f a)
Instance details Defined in Data.Monoid type Rep ( Ap f a) = D1 (' MetaData "Ap" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "Ap" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAp") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a))))
type Rep ( Alt f a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Alt f a) = D1 (' MetaData "Alt" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Alt" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAlt") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a))))
type Rep ( Tagged s b)
Instance details Defined in Data.Tagged type Rep ( Tagged s b) = D1 (' MetaData "Tagged" "Data.Tagged" "tagged-0.8.7-Hh8SrsJ8Ofo2TZerdJ0cCc" ' True ) ( C1 (' MetaCons "Tagged" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unTagged") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)))
type Rep ( These1 f g a)
Instance details Defined in Data.Functor.These type Rep ( These1 f g a) = D1 (' MetaData "These1" "Data.Functor.These" "these-1.1.1.1-GeR95OLAr5rCXHhUN7z1Qo" ' False ) ( C1 (' MetaCons "This1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a))) :+: ( C1 (' MetaCons "That1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g a))) :+: C1 (' MetaCons "These1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a)) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g a)))))
type Rep ( K1 i c p)
Instance details Defined in GHC.Generics type Rep ( K1 i c p) = D1 (' MetaData "K1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "K1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unK1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c)))
type Rep ((f :+: g) p)
Instance details Defined in GHC.Generics type Rep ((f :+: g) p) = D1 (' MetaData ":+:" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "L1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f p))) :+: C1 (' MetaCons "R1" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g p))))
type Rep ((f :*: g) p)
Instance details Defined in GHC.Generics type Rep ((f :: g) p) = D1 (' MetaData "::" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "::" (' InfixI ' RightAssociative 6) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f p)) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g p))))
type Rep (a, b, c, d)
Instance details Defined in GHC.Generics type Rep (a, b, c, d) = D1 (' MetaData "(,,,)" "GHC.Tuple" "ghc-prim" ' False ) ( C1 (' MetaCons "(,,,)" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 d))))
type Rep ( Product f g a)
Instance details Defined in Data.Functor.Product type Rep ( Product f g a) = D1 (' MetaData "Product" "Data.Functor.Product" "base" ' False ) ( C1 (' MetaCons "Pair" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a)) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g a))))
type Rep ( Sum f g a)
Instance details Defined in Data.Functor.Sum type Rep ( Sum f g a) = D1 (' MetaData "Sum" "Data.Functor.Sum" "base" ' False ) ( C1 (' MetaCons "InL" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a))) :+: C1 (' MetaCons "InR" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g a))))
type Rep ( M1 i c f p)
Instance details Defined in GHC.Generics type Rep ( M1 i c f p) = D1 (' MetaData "M1" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "M1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unM1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f p))))
type Rep ((f :.: g) p)
Instance details Defined in GHC.Generics type Rep ((f :.: g) p) = D1 (' MetaData ":.:" "GHC.Generics" "base" ' True ) ( C1 (' MetaCons "Comp1" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unComp1") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f (g p)))))
type Rep (a, b, c, d, e)
Instance details Defined in GHC.Generics type Rep (a, b, c, d, e) = D1 (' MetaData "(,,,,)" "GHC.Tuple" "ghc-prim" ' False ) ( C1 (' MetaCons "(,,,,)" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b)) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 d) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 e)))))
type Rep ( Compose f g a)
Instance details Defined in Data.Functor.Compose type Rep ( Compose f g a) = D1 (' MetaData "Compose" "Data.Functor.Compose" "base" ' True ) ( C1 (' MetaCons "Compose" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getCompose") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f (g a)))))
type Rep ( Flip p a b)
Instance details Defined in Data.Bifunctor.Flip type Rep ( Flip p a b) = D1 (' MetaData "Flip" "Data.Bifunctor.Flip" "bifunctors-5.5.14-4o2vxpA6iYN8K0rfLgtyzm" ' True ) ( C1 (' MetaCons "Flip" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "runFlip") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (p b a))))
type Rep (a, b, c, d, e, f)
Instance details Defined in GHC.Generics type Rep (a, b, c, d, e, f) = D1 (' MetaData "(,,,,,)" "GHC.Tuple" "ghc-prim" ' False ) ( C1 (' MetaCons "(,,,,,)" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c))) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 d) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 e) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 f)))))
type Rep ( Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum type Rep ( Sum p q a b) = D1 (' MetaData "Sum" "Data.Bifunctor.Sum" "bifunctors-5.5.14-4o2vxpA6iYN8K0rfLgtyzm" ' False ) ( C1 (' MetaCons "L2" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (p a b))) :+: C1 (' MetaCons "R2" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (q a b))))
type Rep ( Product f g a b)
Instance details Defined in Data.Bifunctor.Product type Rep ( Product f g a b) = D1 (' MetaData "Product" "Data.Bifunctor.Product" "bifunctors-5.5.14-4o2vxpA6iYN8K0rfLgtyzm" ' False ) ( C1 (' MetaCons "Pair" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a b)) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g a b))))
type Rep (a, b, c, d, e, f, g)
Instance details Defined in GHC.Generics type Rep (a, b, c, d, e, f, g) = D1 (' MetaData "(,,,,,,)" "GHC.Tuple" "ghc-prim" ' False ) ( C1 (' MetaCons "(,,,,,,)" ' PrefixI ' False ) (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 b) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 c))) :: (( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 d) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 e)) :: ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 f) :: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 g)))))
type Rep ( Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen type Rep ( Tannen f p a b) = D1 (' MetaData "Tannen" "Data.Bifunctor.Tannen" "bifunctors-5.5.14-4o2vxpA6iYN8K0rfLgtyzm" ' True ) ( C1 (' MetaCons "Tannen" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "runTannen") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f (p a b)))))
type Rep ( Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff type Rep ( Biff p f g a b) = D1 (' MetaData "Biff" "Data.Bifunctor.Biff" "bifunctors-5.5.14-4o2vxpA6iYN8K0rfLgtyzm" ' True ) ( C1 (' MetaCons "Biff" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "runBiff") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (p (f a) (g b)))))

data family URec a (p :: k) Source #

Constants of unlifted kinds

Since: base-4.9.0.0

Instances

Instances details

Generic1 ( URec ( Ptr ()) :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec ( Ptr ())) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec ( Ptr ()) a -> Rep1 ( URec ( Ptr ())) a Source # to1 :: forall (a :: k0). Rep1 ( URec ( Ptr ())) a -> URec ( Ptr ()) a Source #
Generic1 ( URec Char :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Char ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 ( URec Char ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Char ) a -> URec Char a Source #
Generic1 ( URec Double :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Double ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 ( URec Double ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Double ) a -> URec Double a Source #
Generic1 ( URec Float :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Float ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 ( URec Float ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Float ) a -> URec Float a Source #
Generic1 ( URec Int :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Int ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 ( URec Int ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Int ) a -> URec Int a Source #
Generic1 ( URec Word :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ( URec Word ) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 ( URec Word ) a Source # to1 :: forall (a :: k0). Rep1 ( URec Word ) a -> URec Word a Source #
Foldable ( UAddr :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m Source # foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source # foldr :: (a -> b -> b) -> b -> UAddr a -> b Source # foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source # foldl :: (b -> a -> b) -> b -> UAddr a -> b Source # foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source # foldr1 :: (a -> a -> a) -> UAddr a -> a Source # foldl1 :: (a -> a -> a) -> UAddr a -> a Source # toList :: UAddr a -> [a] Source # null :: UAddr a -> Bool Source # length :: UAddr a -> Int Source # elem :: Eq a => a -> UAddr a -> Bool Source # maximum :: Ord a => UAddr a -> a Source # minimum :: Ord a => UAddr a -> a Source # sum :: Num a => UAddr a -> a Source # product :: Num a => UAddr a -> a Source #
Foldable ( UChar :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m Source # foldMap :: Monoid m => (a -> m) -> UChar a -> m Source # foldMap' :: Monoid m => (a -> m) -> UChar a -> m Source # foldr :: (a -> b -> b) -> b -> UChar a -> b Source # foldr' :: (a -> b -> b) -> b -> UChar a -> b Source # foldl :: (b -> a -> b) -> b -> UChar a -> b Source # foldl' :: (b -> a -> b) -> b -> UChar a -> b Source # foldr1 :: (a -> a -> a) -> UChar a -> a Source # foldl1 :: (a -> a -> a) -> UChar a -> a Source # toList :: UChar a -> [a] Source # null :: UChar a -> Bool Source # length :: UChar a -> Int Source # elem :: Eq a => a -> UChar a -> Bool Source # maximum :: Ord a => UChar a -> a Source # minimum :: Ord a => UChar a -> a Source # sum :: Num a => UChar a -> a Source # product :: Num a => UChar a -> a Source #
Foldable ( UDouble :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m Source # foldMap :: Monoid m => (a -> m) -> UDouble a -> m Source # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m Source # foldr :: (a -> b -> b) -> b -> UDouble a -> b Source # foldr' :: (a -> b -> b) -> b -> UDouble a -> b Source # foldl :: (b -> a -> b) -> b -> UDouble a -> b Source # foldl' :: (b -> a -> b) -> b -> UDouble a -> b Source # foldr1 :: (a -> a -> a) -> UDouble a -> a Source # foldl1 :: (a -> a -> a) -> UDouble a -> a Source # toList :: UDouble a -> [a] Source # null :: UDouble a -> Bool Source # length :: UDouble a -> Int Source # elem :: Eq a => a -> UDouble a -> Bool Source # maximum :: Ord a => UDouble a -> a Source # minimum :: Ord a => UDouble a -> a Source # sum :: Num a => UDouble a -> a Source # product :: Num a => UDouble a -> a Source #
Foldable ( UFloat :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m Source # foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source # foldr :: (a -> b -> b) -> b -> UFloat a -> b Source # foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source # foldl :: (b -> a -> b) -> b -> UFloat a -> b Source # foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source # foldr1 :: (a -> a -> a) -> UFloat a -> a Source # foldl1 :: (a -> a -> a) -> UFloat a -> a Source # toList :: UFloat a -> [a] Source # null :: UFloat a -> Bool Source # length :: UFloat a -> Int Source # elem :: Eq a => a -> UFloat a -> Bool Source # maximum :: Ord a => UFloat a -> a Source # minimum :: Ord a => UFloat a -> a Source # sum :: Num a => UFloat a -> a Source # product :: Num a => UFloat a -> a Source #
Foldable ( UInt :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m Source # foldMap :: Monoid m => (a -> m) -> UInt a -> m Source # foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source # foldr :: (a -> b -> b) -> b -> UInt a -> b Source # foldr' :: (a -> b -> b) -> b -> UInt a -> b Source # foldl :: (b -> a -> b) -> b -> UInt a -> b Source # foldl' :: (b -> a -> b) -> b -> UInt a -> b Source # foldr1 :: (a -> a -> a) -> UInt a -> a Source # foldl1 :: (a -> a -> a) -> UInt a -> a Source # toList :: UInt a -> [a] Source # null :: UInt a -> Bool Source # length :: UInt a -> Int Source # elem :: Eq a => a -> UInt a -> Bool Source # maximum :: Ord a => UInt a -> a Source # minimum :: Ord a => UInt a -> a Source # sum :: Num a => UInt a -> a Source # product :: Num a => UInt a -> a Source #
Foldable ( UWord :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m Source # foldMap :: Monoid m => (a -> m) -> UWord a -> m Source # foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source # foldr :: (a -> b -> b) -> b -> UWord a -> b Source # foldr' :: (a -> b -> b) -> b -> UWord a -> b Source # foldl :: (b -> a -> b) -> b -> UWord a -> b Source # foldl' :: (b -> a -> b) -> b -> UWord a -> b Source # foldr1 :: (a -> a -> a) -> UWord a -> a Source # foldl1 :: (a -> a -> a) -> UWord a -> a Source # toList :: UWord a -> [a] Source # null :: UWord a -> Bool Source # length :: UWord a -> Int Source # elem :: Eq a => a -> UWord a -> Bool Source # maximum :: Ord a => UWord a -> a Source # minimum :: Ord a => UWord a -> a Source # sum :: Num a => UWord a -> a Source # product :: Num a => UWord a -> a Source #
Traversable ( UAddr :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f ( UAddr b) Source # sequenceA :: Applicative f => UAddr (f a) -> f ( UAddr a) Source # mapM :: Monad m => (a -> m b) -> UAddr a -> m ( UAddr b) Source # sequence :: Monad m => UAddr (m a) -> m ( UAddr a) Source #
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) Source # sequenceA :: Applicative f => UChar (f a) -> f ( UChar a) Source # mapM :: Monad m => (a -> m b) -> UChar a -> m ( UChar b) Source # sequence :: Monad m => UChar (m a) -> m ( UChar a) Source #
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) Source # sequenceA :: Applicative f => UDouble (f a) -> f ( UDouble a) Source # mapM :: Monad m => (a -> m b) -> UDouble a -> m ( UDouble b) Source # sequence :: Monad m => UDouble (m a) -> m ( UDouble a) Source #
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) Source # sequenceA :: Applicative f => UFloat (f a) -> f ( UFloat a) Source # mapM :: Monad m => (a -> m b) -> UFloat a -> m ( UFloat b) Source # sequence :: Monad m => UFloat (m a) -> m ( UFloat a) Source #
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) Source # sequenceA :: Applicative f => UInt (f a) -> f ( UInt a) Source # mapM :: Monad m => (a -> m b) -> UInt a -> m ( UInt b) Source # sequence :: Monad m => UInt (m a) -> m ( UInt a) Source #
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) Source # sequenceA :: Applicative f => UWord (f a) -> f ( UWord a) Source # mapM :: Monad m => (a -> m b) -> UWord a -> m ( UWord b) Source # sequence :: Monad m => UWord (m a) -> m ( UWord a) Source #
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 Source # (<$) :: a -> URec Char b -> URec Char a Source #
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 Source # (<$) :: a -> URec Double b -> URec Double a Source #
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 Source # (<$) :: a -> URec Float b -> URec Float a Source #
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 Source # (<$) :: a -> URec Int b -> URec Int a Source #
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 Source # (<$) :: a -> URec Word b -> URec Word a Source #
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 Source # (<$) :: a -> URec ( Ptr ()) b -> URec ( Ptr ()) a Source #
Eq ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (/=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source #
Eq ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool Source # (/=) :: URec Char p -> URec Char p -> Bool Source #
Eq ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool Source # (/=) :: URec Double p -> URec Double p -> Bool Source #
Eq ( URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool Source # (/=) :: URec Float p -> URec Float p -> Bool Source #
Eq ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool Source # (/=) :: URec Int p -> URec Int p -> Bool Source #
Eq ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool Source # (/=) :: URec Word p -> URec Word p -> Bool Source #
Ord ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Ordering Source # (<) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (<=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # max :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source # min :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source #
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 Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source # max :: URec Char p -> URec Char p -> URec Char p Source # min :: URec Char p -> URec Char p -> URec Char p Source #
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 Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source #
Ord ( URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source #
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 Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source # max :: URec Int p -> URec Int p -> URec Int p Source # min :: URec Int p -> URec Int p -> URec Int p Source #
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 Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source # max :: URec Word p -> URec Word p -> URec Word p Source # min :: URec Word p -> URec Word p -> URec Word p Source #
Show ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS Source # show :: URec Char p -> String Source # showList :: [ URec Char p] -> ShowS Source #
Show ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS Source # show :: URec Double p -> String Source # showList :: [ URec Double p] -> ShowS Source #
Show ( URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS Source # show :: URec Float p -> String Source # showList :: [ URec Float p] -> ShowS Source #
Show ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS Source # show :: URec Int p -> String Source # showList :: [ URec Int p] -> ShowS Source #
Show ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS Source # show :: URec Word p -> String Source # showList :: [ URec Word p] -> ShowS Source #
Generic ( URec ( Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec ( Ptr ()) p) :: Type -> Type Source # Methods from :: URec ( Ptr ()) p -> Rep ( URec ( Ptr ()) p) x Source # to :: Rep ( URec ( Ptr ()) p) x -> URec ( Ptr ()) p Source #
Generic ( URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep ( URec Char p) x Source # to :: Rep ( URec Char p) x -> URec Char p Source #
Generic ( URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep ( URec Double p) x Source # to :: Rep ( URec Double p) x -> URec Double p Source #
Generic ( URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep ( URec Float p) x Source # to :: Rep ( URec Float p) x -> URec Float p Source #
Generic ( URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep ( URec Int p) x Source # to :: Rep ( URec Int p) x -> URec Int p Source #
Generic ( URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep ( URec Word p) x Source # to :: Rep ( URec Word p) x -> URec Word p Source #
data URec Word (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# }
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# }
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# }
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# }
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# }
data URec ( Ptr ()) (p :: k)	Used for marking occurrences of `Addr#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec ( Ptr ()) (p :: k) = UAddr { uAddr# :: Addr# }
type Rep1 ( URec Word :: k -> Type )
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 Rep1 ( URec Int :: k -> Type )
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 Rep1 ( URec Float :: k -> Type )
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 Rep1 ( URec Double :: k -> Type )
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 Rep1 ( URec Char :: k -> Type )
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 Rep1 ( URec ( Ptr ()) :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 ( URec ( Ptr ()) :: k -> Type ) = D1 (' MetaData "URec" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "UAddr" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "uAddr#") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( UAddr :: k -> Type )))
type Rep ( URec Word p)
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 )))
type Rep ( URec Int p)
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 )))
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 )))
type Rep ( URec Double p)
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 )))
type Rep ( URec Char p)
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 )))
type Rep ( URec ( Ptr ()) p)
Instance details Defined in GHC.Generics type Rep ( URec ( Ptr ()) p) = D1 (' MetaData "URec" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "UAddr" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "uAddr#") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( UAddr :: Type -> Type )))

data Nat Source #

(Kind) This is the kind of type-level natural numbers.

Instances

Instances details

KnownNat n => HasResolution (n :: Nat )	For example, `Fixed 1000` will give you a `Fixed` with a resolution of 1000.
Instance details Defined in Data.Fixed Methods resolution :: p n -> Integer Source #

data Symbol Source #

(Kind) This is the kind of type-level symbols. Declared here because class IP needs it

Instances

Instances details

SingKind Symbol	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep Symbol Methods fromSing :: forall (a :: Symbol ). Sing a -> DemoteRep Symbol
KnownSymbol a => SingI (a :: Symbol )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing a
type DemoteRep Symbol
Instance details Defined in GHC.Generics type DemoteRep Symbol = String
data Sing (s :: Symbol )
Instance details Defined in GHC.Generics data Sing (s :: Symbol ) where SSym :: forall (s :: Symbol ). KnownSymbol s => Sing s

type family CmpNat (a :: Nat ) (b :: Nat ) :: Ordering where ... Source #

Comparison of type-level naturals, as a function.

Since: base-4.7.0.0

class a ~R# b => Coercible (a :: k) (b :: k) Source #

Coercible is a two-parameter class that has instances for types a and b if the compiler can infer that they have the same representation. This class does not have regular instances; instead they are created on-the-fly during type-checking. Trying to manually declare an instance of Coercible is an error.

Nevertheless one can pretend that the following three kinds of instances exist. First, as a trivial base-case:

instance Coercible a a

Furthermore, for every type constructor there is an instance that allows to coerce under the type constructor. For example, let D be a prototypical type constructor ( data or newtype ) with three type arguments, which have roles nominal , representational resp. phantom . Then there is an instance of the form

instance Coercible b b' => Coercible (D a b c) (D a b' c')

Note that the nominal type arguments are equal, the representational type arguments can differ, but need to have a Coercible instance themself, and the phantom type arguments can be changed arbitrarily.

The third kind of instance exists for every newtype NT = MkNT T and comes in two variants, namely

instance Coercible a T => Coercible a NT

instance Coercible T b => Coercible NT b

This instance is only usable if the constructor MkNT is in scope.

If, as a library author of a type constructor like Set a , you want to prevent a user of your module to write coerce :: Set T -> Set NT , you need to set the role of Set 's type parameter to nominal , by writing

type role Set nominal

For more details about this feature, please refer to Safe Coercions by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.

Since: ghc-prim-4.7.0.0

data StaticPtr a Source #

A reference to a value of type a .

Instances

Instances details

IsStatic StaticPtr	Since: base-4.9.0.0
Instance details Defined in GHC.StaticPtr Methods fromStaticPtr :: StaticPtr a -> StaticPtr a Source #

data CallStack Source #

CallStack s are a lightweight method of obtaining a partial call-stack at any point in the program.

A function can request its call-site with the HasCallStack constraint. For example, we can define

putStrLnWithCallStack :: HasCallStack => String -> IO ()

as a variant of putStrLn that will get its call-site and print it, along with the string given as argument. We can access the call-stack inside putStrLnWithCallStack with callStack .

putStrLnWithCallStack :: HasCallStack => String -> IO ()
putStrLnWithCallStack msg = do
  putStrLn msg
  putStrLn (prettyCallStack callStack)

Thus, if we call putStrLnWithCallStack we will get a formatted call-stack alongside our string.

>>> putStrLnWithCallStack "hello"
hello
CallStack (from HasCallStack):
  putStrLnWithCallStack, called at <interactive>:2:1 in interactive:Ghci1

GHC solves HasCallStack constraints in three steps:

If there is a CallStack in scope -- i.e. the enclosing function has a HasCallStack constraint -- GHC will append the new call-site to the existing CallStack .
If there is no CallStack in scope -- e.g. in the GHCi session above -- and the enclosing definition does not have an explicit type signature, GHC will infer a HasCallStack constraint for the enclosing definition (subject to the monomorphism restriction).
If there is no CallStack in scope and the enclosing definition has an explicit type signature, GHC will solve the HasCallStack constraint for the singleton CallStack containing just the current call-site.

CallStack s do not interact with the RTS and do not require compilation with -prof . On the other hand, as they are built up explicitly via the HasCallStack constraints, they will generally not contain as much information as the simulated call-stacks maintained by the RTS.

A CallStack is a [(String, SrcLoc)] . The String is the name of function that was called, the SrcLoc is the call-site. The list is ordered with the most recently called function at the head.

NOTE: The intrepid user may notice that HasCallStack is just an alias for an implicit parameter ?callStack :: CallStack . This is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.8.1.0

Instances

Instances details

IsList CallStack	Be aware that 'fromList . toList = id' only for unfrozen `CallStack` s, since `toList` removes frozenness information. Since: base-4.9.0.0
Instance details Defined in GHC.Exts Associated Types type Item CallStack Source # Methods fromList :: [ Item CallStack ] -> CallStack Source # fromListN :: Int -> [ Item CallStack ] -> CallStack Source # toList :: CallStack -> [ Item CallStack ] Source #
Show CallStack	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> CallStack -> ShowS Source # show :: CallStack -> String Source # showList :: [ CallStack ] -> ShowS Source #
NFData CallStack	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: CallStack -> () Source #
type Item CallStack
Instance details Defined in GHC.Exts type Item CallStack = ( String , SrcLoc )

data ByteString Source #

A space-efficient representation of a Word8 vector, supporting many efficient operations.

A ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

Instances

Instances details

IsList ByteString	Since: bytestring-0.10.12.0
Instance details Defined in Data.ByteString.Internal Associated Types type Item ByteString Source # Methods fromList :: [ Item ByteString ] -> ByteString Source # fromListN :: Int -> [ Item ByteString ] -> ByteString Source # toList :: ByteString -> [ Item ByteString ] Source #
Eq ByteString
Instance details Defined in Data.ByteString.Internal Methods (==) :: ByteString -> ByteString -> Bool Source # (/=) :: ByteString -> ByteString -> Bool Source #
Data ByteString
Instance details Defined in Data.ByteString.Internal Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> ByteString -> c ByteString Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ByteString Source # toConstr :: ByteString -> Constr Source # dataTypeOf :: ByteString -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ByteString ) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ByteString ) Source # gmapT :: ( forall b. Data b => b -> b) -> ByteString -> ByteString Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> ByteString -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> ByteString -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> ByteString -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> ByteString -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> ByteString -> m ByteString Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> ByteString -> m ByteString Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> ByteString -> m ByteString Source #
Ord ByteString
Instance details Defined in Data.ByteString.Internal Methods compare :: ByteString -> ByteString -> Ordering Source # (<) :: ByteString -> ByteString -> Bool Source # (<=) :: ByteString -> ByteString -> Bool Source # (>) :: ByteString -> ByteString -> Bool Source # (>=) :: ByteString -> ByteString -> Bool Source # max :: ByteString -> ByteString -> ByteString Source # min :: ByteString -> ByteString -> ByteString Source #
Read ByteString
Instance details Defined in Data.ByteString.Internal Methods readsPrec :: Int -> ReadS ByteString Source # readList :: ReadS [ ByteString ] Source # readPrec :: ReadPrec ByteString Source # readListPrec :: ReadPrec [ ByteString ] Source #
Show ByteString
Instance details Defined in Data.ByteString.Internal Methods showsPrec :: Int -> ByteString -> ShowS Source # show :: ByteString -> String Source # showList :: [ ByteString ] -> ShowS Source #
IsString ByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Internal Methods fromString :: String -> ByteString Source #
Semigroup ByteString
Instance details Defined in Data.ByteString.Internal Methods (<>) :: ByteString -> ByteString -> ByteString Source # sconcat :: NonEmpty ByteString -> ByteString Source # stimes :: Integral b => b -> ByteString -> ByteString Source #
Monoid ByteString
Instance details Defined in Data.ByteString.Internal Methods mempty :: ByteString Source # mappend :: ByteString -> ByteString -> ByteString Source # mconcat :: [ ByteString ] -> ByteString Source #
Hashable ByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int Source # hash :: ByteString -> Int Source #
Chunk ByteString
Instance details Defined in Data.Attoparsec.Internal.Types Associated Types type ChunkElem ByteString Source # Methods nullChunk :: ByteString -> Bool Source # pappendChunk :: State ByteString -> ByteString -> State ByteString Source # atBufferEnd :: ByteString -> State ByteString -> Pos Source # bufferElemAt :: ByteString -> Pos -> State ByteString -> Maybe ( ChunkElem ByteString , Int ) Source # chunkElemToChar :: ByteString -> ChunkElem ByteString -> Char Source #
NFData ByteString
Instance details Defined in Data.ByteString.Internal Methods rnf :: ByteString -> () Source #
Print ByteString
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> ByteString -> m () Source # putStr :: MonadIO m => ByteString -> m () Source # hPutStrLn :: MonadIO m => Handle -> ByteString -> m () Source # putStrLn :: MonadIO m => ByteString -> m () Source # putErrLn :: MonadIO m => ByteString -> m () Source #
HeapWords ByteString Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: ByteString -> Int Source #
type State ByteString
Instance details Defined in Data.Attoparsec.Internal.Types type State ByteString = Buffer
type ChunkElem ByteString
Instance details Defined in Data.Attoparsec.Internal.Types type ChunkElem ByteString = Word8
type Item ByteString
Instance details Defined in Data.ByteString.Internal type Item ByteString = Word8

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

An infix synonym for fmap .

The name of this operator is an allusion to $ . Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor .

Examples

Expand

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

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

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

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

Double each element of a list:

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

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

const :: a -> b -> a Source #

const x is a unary function which evaluates to x for all inputs.

>>> const 42 "hello"
42

>>> map (const 42) [0..3]
[42,42,42,42]

toLower :: Char -> Char Source #

Convert a letter to the corresponding lower-case letter, if any. Any other character is returned unchanged.

data Text Source #

A space efficient, packed, unboxed Unicode text type.

Instances

Instances details

Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int Source # hash :: Text -> Int Source #
Chunk Text
Instance details Defined in Data.Attoparsec.Internal.Types Associated Types type ChunkElem Text Source # Methods nullChunk :: Text -> Bool Source # pappendChunk :: State Text -> Text -> State Text Source # atBufferEnd :: Text -> State Text -> Pos Source # bufferElemAt :: Text -> Pos -> State Text -> Maybe ( ChunkElem Text , Int ) Source # chunkElemToChar :: Text -> ChunkElem Text -> Char Source #
Buildable Text
Instance details Defined in Formatting.Buildable Methods build :: Text -> Builder Source #
Print Text
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> Text -> m () Source # putStr :: MonadIO m => Text -> m () Source # hPutStrLn :: MonadIO m => Handle -> Text -> m () Source # putStrLn :: MonadIO m => Text -> m () Source # putErrLn :: MonadIO m => Text -> m () Source #
HeapWords Text Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Text -> Int Source #
ConvertText String Text
Instance details Defined in Protolude.ConvertText Methods toS :: String -> Text Source #
ConvertText Text String
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> String Source #
ConvertText Text Text
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> Text Source #
ConvertText Text Text
Instance details Defined in Protolude.ConvertText Methods toS :: Text0 -> Text Source #
ConvertText Text Text
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> Text0 Source #
type State Text
Instance details Defined in Data.Attoparsec.Internal.Types type State Text = Buffer
type ChunkElem Text
Instance details Defined in Data.Attoparsec.Internal.Types type ChunkElem Text = Char
type Item Text
Instance details Defined in Data.Text type Item Text = Char

data Map k a Source #

A Map from keys k to values a .

The Semigroup operation for Map is union , which prefers values from the left operand. If m1 maps a key k to a value a1 , and m2 maps the same key to a different value a2 , then their union m1 <> m2 maps k to a1 .

Instances

Instances details

Bifoldable Map	Since: containers-0.6.3.1
Instance details Defined in Data.Map.Internal Methods bifold :: Monoid m => Map m m -> m Source # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Map a b -> m Source # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Map a b -> c Source # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Map a b -> c Source #
Eq2 Map	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftEq2 :: (a -> b -> Bool ) -> (c -> d -> Bool ) -> Map a c -> Map b d -> Bool Source #
Ord2 Map	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftCompare2 :: (a -> b -> Ordering ) -> (c -> d -> Ordering ) -> Map a c -> Map b d -> Ordering Source #
Show2 Map	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftShowsPrec2 :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> ( Int -> b -> ShowS ) -> ([b] -> ShowS ) -> Int -> Map a b -> ShowS Source # liftShowList2 :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> ( Int -> b -> ShowS ) -> ([b] -> ShowS ) -> [ Map a b] -> ShowS Source #
Hashable2 Map	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: ( Int -> a -> Int ) -> ( Int -> b -> Int ) -> Int -> Map a b -> Int Source #
( Monad m, ToObjectKey m k, ToJSON m a) => ToJSON m ( Map k a)
Instance details Defined in Text.JSON.Canonical.Class Methods toJSON :: Map k a -> m JSValue Source #
( ReportSchemaErrors m, Ord k, FromObjectKey m k, FromJSON m a) => FromJSON m ( Map k a)
Instance details Defined in Text.JSON.Canonical.Class Methods fromJSON :: JSValue -> m ( Map k a) Source #
Functor ( Map k)
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> Map k a -> Map k b Source # (<$) :: a -> Map k b -> Map k a Source #
Foldable ( Map k)	Folds in order of increasing key.
Instance details Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m Source # foldMap :: Monoid m => (a -> m) -> Map k a -> m Source # foldMap' :: Monoid m => (a -> m) -> Map k a -> m Source # foldr :: (a -> b -> b) -> b -> Map k a -> b Source # foldr' :: (a -> b -> b) -> b -> Map k a -> b Source # foldl :: (b -> a -> b) -> b -> Map k a -> b Source # foldl' :: (b -> a -> b) -> b -> Map k a -> b Source # foldr1 :: (a -> a -> a) -> Map k a -> a Source # foldl1 :: (a -> a -> a) -> Map k a -> a Source # toList :: Map k a -> [a] Source # null :: Map k a -> Bool Source # length :: Map k a -> Int Source # elem :: Eq a => a -> Map k a -> Bool Source # maximum :: Ord a => Map k a -> a Source # minimum :: Ord a => Map k a -> a Source # sum :: Num a => Map k a -> a Source # product :: Num a => Map k a -> a Source #
Traversable ( Map k)	Traverses in order of increasing key.
Instance details Defined in Data.Map.Internal Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f ( Map k b) Source # sequenceA :: Applicative f => Map k (f a) -> f ( Map k a) Source # mapM :: Monad m => (a -> m b) -> Map k a -> m ( Map k b) Source # sequence :: Monad m => Map k (m a) -> m ( Map k a) Source #
Eq k => Eq1 ( Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftEq :: (a -> b -> Bool ) -> Map k a -> Map k b -> Bool Source #
Ord k => Ord1 ( Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftCompare :: (a -> b -> Ordering ) -> Map k a -> Map k b -> Ordering Source #
( Ord k, Read k) => Read1 ( Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftReadsPrec :: ( Int -> ReadS a) -> ReadS [a] -> Int -> ReadS ( Map k a) Source # liftReadList :: ( Int -> ReadS a) -> ReadS [a] -> ReadS [ Map k a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec ( Map k a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ Map k a] Source #
Show k => Show1 ( Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftShowsPrec :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> Int -> Map k a -> ShowS Source # liftShowList :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> [ Map k a] -> ShowS Source #
Hashable k => Hashable1 ( Map k)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Map k a -> Int Source #
Ord k => IsList ( Map k v)	Since: containers-0.5.6.2
Instance details Defined in Data.Map.Internal Associated Types type Item ( Map k v) Source # Methods fromList :: [ Item ( Map k v)] -> Map k v Source # fromListN :: Int -> [ Item ( Map k v)] -> Map k v Source # toList :: Map k v -> [ Item ( Map k v)] Source #
( Eq k, Eq a) => Eq ( Map k a)
Instance details Defined in Data.Map.Internal Methods (==) :: Map k a -> Map k a -> Bool Source # (/=) :: Map k a -> Map k a -> Bool Source #
( Data k, Data a, Ord k) => Data ( Map k a)
Instance details Defined in Data.Map.Internal Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Map k a -> c ( Map k a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Map k a) Source # toConstr :: Map k a -> Constr Source # dataTypeOf :: Map k a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Map k a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Map k a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Map k a -> Map k a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Map k a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Map k a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Map k a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Map k a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Map k a -> m ( Map k a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Map k a -> m ( Map k a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Map k a -> m ( Map k a) Source #
( Ord k, Ord v) => Ord ( Map k v)
Instance details Defined in Data.Map.Internal Methods compare :: Map k v -> Map k v -> Ordering Source # (<) :: Map k v -> Map k v -> Bool Source # (<=) :: Map k v -> Map k v -> Bool Source # (>) :: Map k v -> Map k v -> Bool Source # (>=) :: Map k v -> Map k v -> Bool Source # max :: Map k v -> Map k v -> Map k v Source # min :: Map k v -> Map k v -> Map k v Source #
( Ord k, Read k, Read e) => Read ( Map k e)
Instance details Defined in Data.Map.Internal Methods readsPrec :: Int -> ReadS ( Map k e) Source # readList :: ReadS [ Map k e] Source # readPrec :: ReadPrec ( Map k e) Source # readListPrec :: ReadPrec [ Map k e] Source #
( Show k, Show a) => Show ( Map k a)
Instance details Defined in Data.Map.Internal Methods showsPrec :: Int -> Map k a -> ShowS Source # show :: Map k a -> String Source # showList :: [ Map k a] -> ShowS Source #
Ord k => Semigroup ( Map k v)
Instance details Defined in Data.Map.Internal Methods (<>) :: Map k v -> Map k v -> Map k v Source # sconcat :: NonEmpty ( Map k v) -> Map k v Source # stimes :: Integral b => b -> Map k v -> Map k v Source #
Ord k => Monoid ( Map k v)
Instance details Defined in Data.Map.Internal Methods mempty :: Map k v Source # mappend :: Map k v -> Map k v -> Map k v Source # mconcat :: [ Map k v] -> Map k v Source #
( Hashable k, Hashable v) => Hashable ( Map k v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Map k v -> Int Source # hash :: Map k v -> Int Source #
( NFData k, NFData a) => NFData ( Map k a)
Instance details Defined in Data.Map.Internal Methods rnf :: Map k a -> () Source #
( HeapWords a, HeapWords b) => HeapWords ( Map a b) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Map a b -> Int Source #
type Item ( Map k v)
Instance details Defined in Data.Map.Internal type Item ( Map k v) = (k, v)

data Handle Source #

Haskell defines operations to read and write characters from and to files, represented by values of type Handle . Each value of this type is a handle : a record used by the Haskell run-time system to manage I/O with file system objects. A handle has at least the following properties:

whether it manages input or output or both;
whether it is open , closed or semi-closed ;
whether the object is seekable;
whether buffering is disabled, or enabled on a line or block basis;
a buffer (whose length may be zero).

Most handles will also have a current I/O position indicating where the next input or output operation will occur. A handle is readable if it manages only input or both input and output; likewise, it is writable if it manages only output or both input and output. A handle is open when first allocated. Once it is closed it can no longer be used for either input or output, though an implementation cannot re-use its storage while references remain to it. Handles are in the Show and Eq classes. The string produced by showing a handle is system dependent; it should include enough information to identify the handle for debugging. A handle is equal according to == only to itself; no attempt is made to compare the internal state of different handles for equality.

Instances

Instances details

Eq Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool Source # (/=) :: Handle -> Handle -> Bool Source #
Show Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS Source # show :: Handle -> String Source # showList :: [ Handle ] -> ShowS Source #

data ST s a Source #

The strict ST monad. The ST monad allows for destructive updates, but is escapable (unlike IO). A computation of type ST s a returns a value of type a , and execute in "thread" s . The s parameter is either

an uninstantiated type variable (inside invocations of runST ), or
RealWorld (inside invocations of stToIO ).

It serves to keep the internal states of different invocations of runST separate from each other and from invocations of stToIO .

The >>= and >> operations are strict in the state (though not in values stored in the state). For example,

runST (writeSTRef _|_ v >>= f) = _|_

Instances

Instances details

Monad ( ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b Source # (>>) :: ST s a -> ST s b -> ST s b Source # return :: a -> ST s a Source #
Functor ( ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods fmap :: (a -> b) -> ST s a -> ST s b Source # (<$) :: a -> ST s b -> ST s a Source #
MonadFail ( ST s)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods fail :: String -> ST s a Source #
Applicative ( ST s)	Since: base-4.4.0.0
Instance details Defined in GHC.ST Methods pure :: a -> ST s a Source # (<>) :: ST s (a -> b) -> ST s a -> ST s b Source # liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c Source # (>) :: ST s a -> ST s b -> ST s b Source # (<*) :: ST s a -> ST s b -> ST s a Source #
PrimMonad ( ST s)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState ( ST s) Source # Methods primitive :: ( State# ( PrimState ( ST s)) -> (# State# ( PrimState ( ST s)), a #)) -> ST s a Source #
PrimBase ( ST s)
Instance details Defined in Control.Monad.Primitive Methods internal :: ST s a -> State# ( PrimState ( ST s)) -> (# State# ( PrimState ( ST s)), a #) Source #
MArray ( STUArray s) Word ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word -> ST s Int newArray :: Ix i => (i, i) -> Word -> ST s ( STUArray s i Word ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word ) unsafeRead :: Ix i => STUArray s i Word -> Int -> ST s Word unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> ST s ()
MArray ( STUArray s) Word8 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word8 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word8 -> ST s Int newArray :: Ix i => (i, i) -> Word8 -> ST s ( STUArray s i Word8 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word8 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word8 ) unsafeRead :: Ix i => STUArray s i Word8 -> Int -> ST s Word8 unsafeWrite :: Ix i => STUArray s i Word8 -> Int -> Word8 -> ST s ()
MArray ( STUArray s) Word64 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word64 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word64 -> ST s Int newArray :: Ix i => (i, i) -> Word64 -> ST s ( STUArray s i Word64 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word64 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word64 ) unsafeRead :: Ix i => STUArray s i Word64 -> Int -> ST s Word64 unsafeWrite :: Ix i => STUArray s i Word64 -> Int -> Word64 -> ST s ()
MArray ( STUArray s) Word32 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word32 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word32 -> ST s Int newArray :: Ix i => (i, i) -> Word32 -> ST s ( STUArray s i Word32 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word32 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word32 ) unsafeRead :: Ix i => STUArray s i Word32 -> Int -> ST s Word32 unsafeWrite :: Ix i => STUArray s i Word32 -> Int -> Word32 -> ST s ()
MArray ( STUArray s) Word16 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word16 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Word16 -> ST s Int newArray :: Ix i => (i, i) -> Word16 -> ST s ( STUArray s i Word16 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word16 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Word16 ) unsafeRead :: Ix i => STUArray s i Word16 -> Int -> ST s Word16 unsafeWrite :: Ix i => STUArray s i Word16 -> Int -> Word16 -> ST s ()
MArray ( STUArray s) Int ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int -> ST s Int newArray :: Ix i => (i, i) -> Int -> ST s ( STUArray s i Int ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int ) unsafeRead :: Ix i => STUArray s i Int -> Int -> ST s Int unsafeWrite :: Ix i => STUArray s i Int -> Int -> Int -> ST s ()
MArray ( STUArray s) Int8 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int8 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int8 -> ST s Int newArray :: Ix i => (i, i) -> Int8 -> ST s ( STUArray s i Int8 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int8 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int8 ) unsafeRead :: Ix i => STUArray s i Int8 -> Int -> ST s Int8 unsafeWrite :: Ix i => STUArray s i Int8 -> Int -> Int8 -> ST s ()
MArray ( STUArray s) Int64 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int64 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int64 -> ST s Int newArray :: Ix i => (i, i) -> Int64 -> ST s ( STUArray s i Int64 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int64 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int64 ) unsafeRead :: Ix i => STUArray s i Int64 -> Int -> ST s Int64 unsafeWrite :: Ix i => STUArray s i Int64 -> Int -> Int64 -> ST s ()
MArray ( STUArray s) Int32 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int32 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int32 -> ST s Int newArray :: Ix i => (i, i) -> Int32 -> ST s ( STUArray s i Int32 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int32 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int32 ) unsafeRead :: Ix i => STUArray s i Int32 -> Int -> ST s Int32 unsafeWrite :: Ix i => STUArray s i Int32 -> Int -> Int32 -> ST s ()
MArray ( STUArray s) Int16 ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int16 -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Int16 -> ST s Int newArray :: Ix i => (i, i) -> Int16 -> ST s ( STUArray s i Int16 ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int16 ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Int16 ) unsafeRead :: Ix i => STUArray s i Int16 -> Int -> ST s Int16 unsafeWrite :: Ix i => STUArray s i Int16 -> Int -> Int16 -> ST s ()
MArray ( STUArray s) Float ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Float -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Float -> ST s Int newArray :: Ix i => (i, i) -> Float -> ST s ( STUArray s i Float ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Float ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Float ) unsafeRead :: Ix i => STUArray s i Float -> Int -> ST s Float unsafeWrite :: Ix i => STUArray s i Float -> Int -> Float -> ST s ()
MArray ( STUArray s) Double ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Double -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Double -> ST s Int newArray :: Ix i => (i, i) -> Double -> ST s ( STUArray s i Double ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Double ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Double ) unsafeRead :: Ix i => STUArray s i Double -> Int -> ST s Double unsafeWrite :: Ix i => STUArray s i Double -> Int -> Double -> ST s ()
MArray ( STUArray s) Char ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Char -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Char -> ST s Int newArray :: Ix i => (i, i) -> Char -> ST s ( STUArray s i Char ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Char ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Char ) unsafeRead :: Ix i => STUArray s i Char -> Int -> ST s Char unsafeWrite :: Ix i => STUArray s i Char -> Int -> Char -> ST s ()
MArray ( STUArray s) Bool ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Bool -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i Bool -> ST s Int newArray :: Ix i => (i, i) -> Bool -> ST s ( STUArray s i Bool ) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Bool ) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i Bool ) unsafeRead :: Ix i => STUArray s i Bool -> Int -> ST s Bool unsafeWrite :: Ix i => STUArray s i Bool -> Int -> Bool -> ST s ()
MArray ( STArray s) e ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STArray s i e -> ST s (i, i) Source # getNumElements :: Ix i => STArray s i e -> ST s Int newArray :: Ix i => (i, i) -> e -> ST s ( STArray s i e) Source # newArray_ :: Ix i => (i, i) -> ST s ( STArray s i e) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STArray s i e) unsafeRead :: Ix i => STArray s i e -> Int -> ST s e unsafeWrite :: Ix i => STArray s i e -> Int -> e -> ST s ()
RandomGen g => FrozenGen ( STGen g) ( ST s)
Instance details Defined in System.Random.Stateful Associated Types type MutableGen ( STGen g) ( ST s) = (g :: Type ) Source # Methods freezeGen :: MutableGen ( STGen g) ( ST s) -> ST s ( STGen g) Source # thawGen :: STGen g -> ST s ( MutableGen ( STGen g) ( ST s)) Source #
MArray ( STUArray s) ( StablePtr a) ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i ( StablePtr a) -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i ( StablePtr a) -> ST s Int newArray :: Ix i => (i, i) -> StablePtr a -> ST s ( STUArray s i ( StablePtr a)) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( StablePtr a)) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( StablePtr a)) unsafeRead :: Ix i => STUArray s i ( StablePtr a) -> Int -> ST s ( StablePtr a) unsafeWrite :: Ix i => STUArray s i ( StablePtr a) -> Int -> StablePtr a -> ST s ()
MArray ( STUArray s) ( Ptr a) ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i ( Ptr a) -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i ( Ptr a) -> ST s Int newArray :: Ix i => (i, i) -> Ptr a -> ST s ( STUArray s i ( Ptr a)) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( Ptr a)) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( Ptr a)) unsafeRead :: Ix i => STUArray s i ( Ptr a) -> Int -> ST s ( Ptr a) unsafeWrite :: Ix i => STUArray s i ( Ptr a) -> Int -> Ptr a -> ST s ()
MArray ( STUArray s) ( FunPtr a) ( ST s)
Instance details Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i ( FunPtr a) -> ST s (i, i) Source # getNumElements :: Ix i => STUArray s i ( FunPtr a) -> ST s Int newArray :: Ix i => (i, i) -> FunPtr a -> ST s ( STUArray s i ( FunPtr a)) Source # newArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( FunPtr a)) Source # unsafeNewArray_ :: Ix i => (i, i) -> ST s ( STUArray s i ( FunPtr a)) unsafeRead :: Ix i => STUArray s i ( FunPtr a) -> Int -> ST s ( FunPtr a) unsafeWrite :: Ix i => STUArray s i ( FunPtr a) -> Int -> FunPtr a -> ST s ()
Show ( ST s a)	Since: base-2.1
Instance details Defined in GHC.ST Methods showsPrec :: Int -> ST s a -> ShowS Source # show :: ST s a -> String Source # showList :: [ ST s a] -> ShowS Source #
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 Source # sconcat :: NonEmpty ( ST s a) -> ST s a Source # stimes :: Integral b => b -> ST s a -> ST s a Source #
Monoid a => Monoid ( ST s a)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods mempty :: ST s a Source # mappend :: ST s a -> ST s a -> ST s a Source # mconcat :: [ ST s a] -> ST s a Source #
RandomGen r => RandomGenM ( STGenM r s) r ( ST s)
Instance details Defined in System.Random.Stateful Methods applyRandomGenM :: (r -> (a, r)) -> STGenM r s -> ST s a Source #
RandomGen g => StatefulGen ( STGenM g s) ( ST s)
Instance details Defined in System.Random.Stateful Methods uniformWord32R :: Word32 -> STGenM g s -> ST s Word32 Source # uniformWord64R :: Word64 -> STGenM g s -> ST s Word64 Source # uniformWord8 :: STGenM g s -> ST s Word8 Source # uniformWord16 :: STGenM g s -> ST s Word16 Source # uniformWord32 :: STGenM g s -> ST s Word32 Source # uniformWord64 :: STGenM g s -> ST s Word64 Source # uniformShortByteString :: Int -> STGenM g s -> ST s ShortByteString Source #
type PrimState ( ST s)
Instance details Defined in Control.Monad.Primitive type PrimState ( ST s) = s
type MutableGen ( STGen g) ( ST s)
Instance details Defined in System.Random.Stateful type MutableGen ( STGen g) ( ST s) = STGenM g s

class Bifunctor (p :: Type -> Type -> Type ) where Source #

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor , a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask .

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second .

If you supply bimap , you should ensure that:

bimap id id ≡ id

If you supply first and second , ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: base-4.8.0.0

Minimal complete definition

bimap | first , second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d Source #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

Expand

>>> bimap toUpper (+1) ('j', 3)
('J',4)

>>> bimap toUpper (+1) (Left 'j')
Left 'J'

>>> bimap toUpper (+1) (Right 3)
Right 4

first :: (a -> b) -> p a c -> p b c Source #

Map covariantly over the first argument.

first f ≡ bimap f id

Examples

Expand

>>> first toUpper ('j', 3)
('J',3)

>>> first toUpper (Left 'j')
Left 'J'

second :: (b -> c) -> p a b -> p a c Source #

Map covariantly over the second argument.

second ≡ bimap id

Examples

Expand

>>> second (+1) ('j', 3)
('j',4)

>>> second (+1) (Right 3)
Right 4

Instances

Instances details

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d Source # first :: (a -> b) -> Either a c -> Either b c Source # second :: (b -> c) -> Either a b -> Either a c Source #
Bifunctor (,)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) Source # first :: (a -> b) -> (a, c) -> (b, c) Source # second :: (b -> c) -> (a, b) -> (a, c) Source #
Bifunctor Arg	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d Source # first :: (a -> b) -> Arg a c -> Arg b c Source # second :: (b -> c) -> Arg a b -> Arg a c Source #
Bifunctor These
Instance details Defined in Data.These Methods bimap :: (a -> b) -> (c -> d) -> These a c -> These b d Source # first :: (a -> b) -> These a c -> These b c Source # second :: (b -> c) -> These a b -> These a c Source #
Bifunctor Pair
Instance details Defined in Data.Strict.Tuple Methods bimap :: (a -> b) -> (c -> d) -> Pair a c -> Pair b d Source # first :: (a -> b) -> Pair a c -> Pair b c Source # second :: (b -> c) -> Pair a b -> Pair a c Source #
Bifunctor These
Instance details Defined in Data.Strict.These Methods bimap :: (a -> b) -> (c -> d) -> These a c -> These b d Source # first :: (a -> b) -> These a c -> These b c Source # second :: (b -> c) -> These a b -> These a c Source #
Bifunctor Either
Instance details Defined in Data.Strict.Either Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d Source # first :: (a -> b) -> Either a c -> Either b c Source # second :: (b -> c) -> Either a b -> Either a c Source #
Bifunctor ( (,,) x1)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) Source # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) Source # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) Source #
Bifunctor ( Const :: Type -> Type -> Type )	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d Source # first :: (a -> b) -> Const a c -> Const b c Source # second :: (b -> c) -> Const a b -> Const a c Source #
Bifunctor ( Tagged :: Type -> Type -> Type )
Instance details Defined in Data.Tagged Methods bimap :: (a -> b) -> (c -> d) -> Tagged a c -> Tagged b d Source # first :: (a -> b) -> Tagged a c -> Tagged b c Source # second :: (b -> c) -> Tagged a b -> Tagged a c Source #
Bifunctor ( K1 i :: Type -> Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d Source # first :: (a -> b) -> K1 i a c -> K1 i b c Source # second :: (b -> c) -> K1 i a b -> K1 i a c Source #
Bifunctor ( (,,,) x1 x2)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) Source # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) Source # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) Source #
Bifunctor ( (,,,,) x1 x2 x3)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) Source # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) Source # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) Source #
Bifunctor p => Bifunctor ( Flip p)
Instance details Defined in Data.Bifunctor.Flip Methods bimap :: (a -> b) -> (c -> d) -> Flip p a c -> Flip p b d Source # first :: (a -> b) -> Flip p a c -> Flip p b c Source # second :: (b -> c) -> Flip p a b -> Flip p a c Source #
Bifunctor ( (,,,,,) x1 x2 x3 x4)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) Source # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) Source # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) Source #
( Bifunctor p, Bifunctor q) => Bifunctor ( Sum p q)
Instance details Defined in Data.Bifunctor.Sum Methods bimap :: (a -> b) -> (c -> d) -> Sum p q a c -> Sum p q b d Source # first :: (a -> b) -> Sum p q a c -> Sum p q b c Source # second :: (b -> c) -> Sum p q a b -> Sum p q a c Source #
( Bifunctor f, Bifunctor g) => Bifunctor ( Product f g)
Instance details Defined in Data.Bifunctor.Product Methods bimap :: (a -> b) -> (c -> d) -> Product f g a c -> Product f g b d Source # first :: (a -> b) -> Product f g a c -> Product f g b c Source # second :: (b -> c) -> Product f g a b -> Product f g a c Source #
Bifunctor ( (,,,,,,) x1 x2 x3 x4 x5)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) Source # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) Source # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) Source #
( Functor f, Bifunctor p) => Bifunctor ( Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods bimap :: (a -> b) -> (c -> d) -> Tannen f p a c -> Tannen f p b d Source # first :: (a -> b) -> Tannen f p a c -> Tannen f p b c Source # second :: (b -> c) -> Tannen f p a b -> Tannen f p a c Source #
( Bifunctor p, Functor f, Functor g) => Bifunctor ( Biff p f g)
Instance details Defined in Data.Bifunctor.Biff Methods bimap :: (a -> b) -> (c -> d) -> Biff p f g a c -> Biff p f g b d Source # first :: (a -> b) -> Biff p f g a c -> Biff p f g b c Source # second :: (b -> c) -> Biff p f g a b -> Biff p f g a c Source #

forM_ :: ( Foldable t, Monad m) => t a -> (a -> m b) -> m () Source #

forM_ is mapM_ with its arguments flipped. For a version that doesn't ignore the results see forM .

As of base 4.8.0.0, forM_ is just for_ , specialized to Monad .

mapM_ :: ( Foldable t, Monad m) => (a -> m b) -> t a -> m () Source #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see mapM .

As of base 4.8.0.0, mapM_ is just traverse_ , specialized to Monad .

forkOnWithUnmask :: Int -> (( forall a. IO a -> IO a) -> IO ()) -> IO ThreadId Source #

Like forkIOWithUnmask , but the child thread is pinned to the given CPU, as with forkOn .

Since: base-4.4.0.0

forkIOWithUnmask :: (( forall a. IO a -> IO a) -> IO ()) -> IO ThreadId Source #

Like forkIO , but the child thread is passed a function that can be used to unmask asynchronous exceptions. This function is typically used in the following way

 ... mask_ $ forkIOWithUnmask $ \unmask ->
                catch (unmask ...) handler

so that the exception handler in the child thread is established with asynchronous exceptions masked, meanwhile the main body of the child thread is executed in the unmasked state.

Note that the unmask function passed to the child thread should only be used in that thread; the behaviour is undefined if it is invoked in a different thread.

Since: base-4.4.0.0

forkOn :: Int -> IO () -> IO ThreadId Source #

Like forkIO , but lets you specify on which capability the thread should run. Unlike a forkIO thread, a thread created by forkOn will stay on the same capability for its entire lifetime ( forkIO threads can migrate between capabilities according to the scheduling policy). forkOn is useful for overriding the scheduling policy when you know in advance how best to distribute the threads.

The Int argument specifies a capability number (see getNumCapabilities ). Typically capabilities correspond to physical processors, but the exact behaviour is implementation-dependent. The value passed to forkOn is interpreted modulo the total number of capabilities as returned by getNumCapabilities .

GHC note: the number of capabilities is specified by the +RTS -N option when the program is started. Capabilities can be fixed to actual processor cores with +RTS -qa if the underlying operating system supports that, although in practice this is usually unnecessary (and may actually degrade performance in some cases - experimentation is recommended).

Since: base-4.4.0.0

forkOS :: IO () -> IO ThreadId Source #

Like forkIO , this sparks off a new thread to run the IO computation passed as the first argument, and returns the ThreadId of the newly created thread.

However, forkOS creates a bound thread, which is necessary if you need to call foreign (non-Haskell) libraries that make use of thread-local state, such as OpenGL (see Control.Concurrent ).

Using forkOS instead of forkIO makes no difference at all to the scheduling behaviour of the Haskell runtime system. It is a common misconception that you need to use forkOS instead of forkIO to avoid blocking all the Haskell threads when making a foreign call; this isn't the case. To allow foreign calls to be made without blocking all the Haskell threads (with GHC), it is only necessary to use the -threaded option when linking your program, and to make sure the foreign import is not marked unsafe .

forkIO :: IO () -> IO ThreadId Source #

Creates a new thread to run the IO computation passed as the first argument, and returns the ThreadId of the newly created thread.

The new thread will be a lightweight, unbound thread. Foreign calls made by this thread are not guaranteed to be made by any particular OS thread; if you need foreign calls to be made by a particular OS thread, then use forkOS instead.

The new thread inherits the masked state of the parent (see mask ).

The newly created thread has an exception handler that discards the exceptions BlockedIndefinitelyOnMVar , BlockedIndefinitelyOnSTM , and ThreadKilled , and passes all other exceptions to the uncaught exception handler.

data ThreadId Source #

A ThreadId is an abstract type representing a handle to a thread. ThreadId is an instance of Eq , Ord and Show , where the Ord instance implements an arbitrary total ordering over ThreadId s. The Show instance lets you convert an arbitrary-valued ThreadId to string form; showing a ThreadId value is occasionally useful when debugging or diagnosing the behaviour of a concurrent program.

Note : in GHC, if you have a ThreadId , you essentially have a pointer to the thread itself. This means the thread itself can't be garbage collected until you drop the ThreadId . This misfeature will hopefully be corrected at a later date.

Instances

Instances details

Eq ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadId -> ThreadId -> Bool Source # (/=) :: ThreadId -> ThreadId -> Bool Source #
Ord ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: ThreadId -> ThreadId -> Ordering Source # (<) :: ThreadId -> ThreadId -> Bool Source # (<=) :: ThreadId -> ThreadId -> Bool Source # (>) :: ThreadId -> ThreadId -> Bool Source # (>=) :: ThreadId -> ThreadId -> Bool Source # max :: ThreadId -> ThreadId -> ThreadId Source # min :: ThreadId -> ThreadId -> ThreadId Source #
Show ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> ThreadId -> ShowS Source # show :: ThreadId -> String Source # showList :: [ ThreadId ] -> ShowS Source #
Hashable ThreadId
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ThreadId -> Int Source # hash :: ThreadId -> Int Source #
NFData ThreadId	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ThreadId -> () Source #

concurrently :: IO a -> IO b -> IO (a, b) Source #

Run two IO actions concurrently, and return both results. If either action throws an exception at any time, then the other action is cancel led, and the exception is re-thrown by concurrently .

concurrently left right =
  withAsync left $ \a ->
  withAsync right $ \b ->
  waitBoth a b

race_ :: IO a -> IO b -> IO () Source #

Like race , but the result is ignored.

race :: IO a -> IO b -> IO ( Either a b) Source #

Run two IO actions concurrently, and return the first to finish. The loser of the race is cancel led.

race left right =
  withAsync left $ \a ->
  withAsync right $ \b ->
  waitEither a b

link2 :: Async a -> Async b -> IO () Source #

Link two Async s together, such that if either raises an exception, the same exception is re-thrown in the other Async , wrapped in ExceptionInLinkedThread .

link2 ignores AsyncCancelled exceptions, so that it's possible to cancel either thread without cancelling the other. If you want different behaviour, use link2Only .

link :: Async a -> IO () Source #

Link the given Async to the current thread, such that if the Async raises an exception, that exception will be re-thrown in the current thread, wrapped in ExceptionInLinkedThread .

link ignores AsyncCancelled exceptions thrown in the other thread, so that it's safe to cancel a thread you're linked to. If you want different behaviour, use linkOnly .

waitBoth :: Async a -> Async b -> IO (a, b) Source #

Waits for both Async s to finish, but if either of them throws an exception before they have both finished, then the exception is re-thrown by waitBoth .

waitEitherCancel :: Async a -> Async b -> IO ( Either a b) Source #

Like waitEither , but also cancel s both Async s before returning.

waitEither_ :: Async a -> Async b -> IO () Source #

Like waitEither , but the result is ignored.

waitEither :: Async a -> Async b -> IO ( Either a b) Source #

Wait for the first of two Async s to finish. If the Async that finished first raised an exception, then the exception is re-thrown by waitEither .

waitEitherCatchCancel :: Async a -> Async b -> IO ( Either ( Either SomeException a) ( Either SomeException b)) Source #

Like waitEitherCatch , but also cancel s both Async s before returning.

waitEitherCatch :: Async a -> Async b -> IO ( Either ( Either SomeException a) ( Either SomeException b)) Source #

Wait for the first of two Async s to finish.

waitAnyCancel :: [ Async a] -> IO ( Async a, a) Source #

Like waitAny , but also cancels the other asynchronous operations as soon as one has completed.

waitAny :: [ Async a] -> IO ( Async a, a) Source #

Wait for any of the supplied Async s to complete. If the first to complete throws an exception, then that exception is re-thrown by waitAny .

If multiple Async s complete or have completed, then the value returned corresponds to the first completed Async in the list.

waitAnyCatchCancel :: [ Async a] -> IO ( Async a, Either SomeException a) Source #

Like waitAnyCatch , but also cancels the other asynchronous operations as soon as one has completed.

waitAnyCatch :: [ Async a] -> IO ( Async a, Either SomeException a) Source #

Wait for any of the supplied asynchronous operations to complete. The value returned is a pair of the Async that completed, and the result that would be returned by wait on that Async .

If multiple Async s complete or have completed, then the value returned corresponds to the first completed Async in the list.

cancelWith :: Exception e => Async a -> e -> IO () Source #

Cancel an asynchronous action by throwing the supplied exception to it.

cancelWith a x = throwTo (asyncThreadId a) x

The notes about the synchronous nature of cancel also apply to cancelWith .

cancel :: Async a -> IO () Source #

Cancel an asynchronous action by throwing the AsyncCancelled exception to it, and waiting for the Async thread to quit. Has no effect if the Async has already completed.

cancel a = throwTo (asyncThreadId a) AsyncCancelled <* waitCatch a

Note that cancel will not terminate until the thread the Async refers to has terminated. This means that cancel will block for as long said thread blocks when receiving an asynchronous exception.

For example, it could block if:

It's executing a foreign call, and thus cannot receive the asynchronous exception;
It's executing some cleanup handler after having received the exception, and the handler is blocking.

poll :: Async a -> IO ( Maybe ( Either SomeException a)) Source #

Check whether an Async has completed yet. If it has not completed yet, then the result is Nothing , otherwise the result is Just e where e is Left x if the Async raised an exception x , or Right a if it returned a value a .

poll = atomically . pollSTM

waitCatch :: Async a -> IO ( Either SomeException a) Source #

Wait for an asynchronous action to complete, and return either Left e if the action raised an exception e , or Right a if it returned a value a .

waitCatch = atomically . waitCatchSTM

wait :: Async a -> IO a Source #

Wait for an asynchronous action to complete, and return its value. If the asynchronous action threw an exception, then the exception is re-thrown by wait .

wait = atomically . waitSTM

withAsyncOn :: Int -> IO a -> ( Async a -> IO b) -> IO b Source #

Like withAsync but uses forkOn internally.

withAsyncBound :: IO a -> ( Async a -> IO b) -> IO b Source #

Like withAsync but uses forkOS internally.

withAsync :: IO a -> ( Async a -> IO b) -> IO b Source #

Spawn an asynchronous action in a separate thread, and pass its Async handle to the supplied function. When the function returns or throws an exception, uninterruptibleCancel is called on the Async .

withAsync action inner = mask $ \restore -> do
  a <- async (restore action)
  restore (inner a) `finally` uninterruptibleCancel a

This is a useful variant of async that ensures an Async is never left running unintentionally.

Note: a reference to the child thread is kept alive until the call to withAsync returns, so nesting many withAsync calls requires linear memory.

asyncOn :: Int -> IO a -> IO ( Async a) Source #

Like async but using forkOn internally.

asyncBound :: IO a -> IO ( Async a) Source #

Like async but using forkOS internally.

async :: IO a -> IO ( Async a) Source #

Spawn an asynchronous action in a separate thread.

Like for forkIO , the action may be left running unintentinally (see module-level documentation for details).

Use withAsync style functions wherever you can instead!

data Async a Source #

An asynchronous action spawned by async or withAsync . Asynchronous actions are executed in a separate thread, and operations are provided for waiting for asynchronous actions to complete and obtaining their results (see e.g. wait ).

Instances

Instances details

Functor Async
Instance details Defined in Control.Concurrent.Async Methods fmap :: (a -> b) -> Async a -> Async b Source # (<$) :: a -> Async b -> Async a Source #
Eq ( Async a)
Instance details Defined in Control.Concurrent.Async Methods (==) :: Async a -> Async a -> Bool Source # (/=) :: Async a -> Async a -> Bool Source #
Ord ( Async a)
Instance details Defined in Control.Concurrent.Async Methods compare :: Async a -> Async a -> Ordering Source # (<) :: Async a -> Async a -> Bool Source # (<=) :: Async a -> Async a -> Bool Source # (>) :: Async a -> Async a -> Bool Source # (>=) :: Async a -> Async a -> Bool Source # max :: Async a -> Async a -> Async a Source # min :: Async a -> Async a -> Async a Source #
Hashable ( Async a)
Instance details Defined in Control.Concurrent.Async Methods hashWithSalt :: Int -> Async a -> Int Source # hash :: Async a -> Int Source #

newtype Concurrently a Source #

A value of type Concurrently a is an IO operation that can be composed with other Concurrently values, using the Applicative and Alternative instances.

Calling runConcurrently on a value of type Concurrently a will execute the IO operations it contains concurrently, before delivering the result of type a .

For example

(page1, page2, page3)
    <- runConcurrently $ (,,)
    <$> Concurrently (getURL "url1")
    <*> Concurrently (getURL "url2")
    <*> Concurrently (getURL "url3")

Constructors

Concurrently
Fields runConcurrently :: IO a

Instances

Instances details

Functor Concurrently
Instance details Defined in Control.Concurrent.Async Methods fmap :: (a -> b) -> Concurrently a -> Concurrently b Source # (<$) :: a -> Concurrently b -> Concurrently a Source #
Applicative Concurrently
Instance details Defined in Control.Concurrent.Async Methods pure :: a -> Concurrently a Source # (<>) :: Concurrently (a -> b) -> Concurrently a -> Concurrently b Source # liftA2 :: (a -> b -> c) -> Concurrently a -> Concurrently b -> Concurrently c Source # (>) :: Concurrently a -> Concurrently b -> Concurrently b Source # (<*) :: Concurrently a -> Concurrently b -> Concurrently a Source #
Alternative Concurrently
Instance details Defined in Control.Concurrent.Async Methods empty :: Concurrently a Source # (<\|>) :: Concurrently a -> Concurrently a -> Concurrently a Source # some :: Concurrently a -> Concurrently [a] Source # many :: Concurrently a -> Concurrently [a] Source #
Semigroup a => Semigroup ( Concurrently a)	Only defined by `async` for `base >= 4.9` Since: async-2.1.0
Instance details Defined in Control.Concurrent.Async Methods (<>) :: Concurrently a -> Concurrently a -> Concurrently a Source # sconcat :: NonEmpty ( Concurrently a) -> Concurrently a Source # stimes :: Integral b => b -> Concurrently a -> Concurrently a Source #
( Semigroup a, Monoid a) => Monoid ( Concurrently a)	Since: async-2.1.0
Instance details Defined in Control.Concurrent.Async Methods mempty :: Concurrently a Source # mappend :: Concurrently a -> Concurrently a -> Concurrently a Source # mconcat :: [ Concurrently a] -> Concurrently a Source #

isSpace :: Char -> Bool Source #

Returns True for any Unicode space character, and the control characters \t , \n , \r , \f , \v .

isAlpha :: Char -> Bool Source #

Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters). This function is equivalent to isLetter .

isDigit :: Char -> Bool Source #

Selects ASCII digits, i.e. '0' .. '9' .

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

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

```
some v = (:) <$> v <*> many v
```
```
many v = some v <|> pure []
```

Minimal complete definition

empty , (<|>)

Methods

empty :: f a Source #

The identity of <|>

(<|>) :: f a -> f a -> f a infixl 3 Source #

An associative binary operation

some :: f a -> f [a] Source #

One or more.

many :: f a -> f [a] Source #

Zero or more.

Instances

Instances details

Alternative []	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: [a] Source # (<\|>) :: [a] -> [a] -> [a] Source # some :: [a] -> [[a]] Source # many :: [a] -> [[a]] Source #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a Source # (<\|>) :: Maybe a -> Maybe a -> Maybe a Source # some :: Maybe a -> Maybe [a] Source # many :: Maybe a -> Maybe [a] Source #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a Source # (<\|>) :: IO a -> IO a -> IO a Source # some :: IO a -> IO [a] Source # many :: IO a -> IO [a] Source #
Alternative IResult
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: IResult a Source # (<\|>) :: IResult a -> IResult a -> IResult a Source # some :: IResult a -> IResult [a] Source # many :: IResult a -> IResult [a] Source #
Alternative Result
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: Result a Source # (<\|>) :: Result a -> Result a -> Result a Source # some :: Result a -> Result [a] Source # many :: Result a -> Result [a] Source #
Alternative Parser
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: Parser a Source # (<\|>) :: Parser a -> Parser a -> Parser a Source # some :: Parser a -> Parser [a] Source # many :: Parser a -> Parser [a] Source #
Alternative Concurrently
Instance details Defined in Control.Concurrent.Async Methods empty :: Concurrently a Source # (<\|>) :: Concurrently a -> Concurrently a -> Concurrently a Source # some :: Concurrently a -> Concurrently [a] Source # many :: Concurrently a -> Concurrently [a] Source #
Alternative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods empty :: Option a Source # (<\|>) :: Option a -> Option a -> Option a Source # some :: Option a -> Option [a] Source # many :: Option a -> Option [a] Source #
Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a Source # (<\|>) :: ZipList a -> ZipList a -> ZipList a Source # some :: ZipList a -> ZipList [a] Source # many :: ZipList a -> ZipList [a] Source #
Alternative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods empty :: STM a Source # (<\|>) :: STM a -> STM a -> STM a Source # some :: STM a -> STM [a] Source # many :: STM a -> STM [a] Source #
Alternative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: ReadP a Source # (<\|>) :: ReadP a -> ReadP a -> ReadP a Source # some :: ReadP a -> ReadP [a] Source # many :: ReadP a -> ReadP [a] Source #
Alternative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a Source # (<\|>) :: Seq a -> Seq a -> Seq a Source # some :: Seq a -> Seq [a] Source # many :: Seq a -> Seq [a] Source #
Alternative DList
Instance details Defined in Data.DList.Internal Methods empty :: DList a Source # (<\|>) :: DList a -> DList a -> DList a Source # some :: DList a -> DList [a] Source # many :: DList a -> DList [a] Source #
Alternative SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods empty :: SmallArray a Source # (<\|>) :: SmallArray a -> SmallArray a -> SmallArray a Source # some :: SmallArray a -> SmallArray [a] Source # many :: SmallArray a -> SmallArray [a] Source #
Alternative Array
Instance details Defined in Data.Primitive.Array Methods empty :: Array a Source # (<\|>) :: Array a -> Array a -> Array a Source # some :: Array a -> Array [a] Source # many :: Array a -> Array [a] Source #
Alternative Vector
Instance details Defined in Data.Vector Methods empty :: Vector a Source # (<\|>) :: Vector a -> Vector a -> Vector a Source # some :: Vector a -> Vector [a] Source # many :: Vector a -> Vector [a] Source #
Alternative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: P a Source # (<\|>) :: P a -> P a -> P a Source # some :: P a -> P [a] Source # many :: P a -> P [a] Source #
Alternative ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: U1 a Source # (<\|>) :: U1 a -> U1 a -> U1 a Source # some :: U1 a -> U1 [a] Source # many :: U1 a -> U1 [a] Source #
Alternative ( Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods empty :: Parser i a Source # (<\|>) :: Parser i a -> Parser i a -> Parser i a Source # some :: Parser i a -> Parser i [a] Source # many :: Parser i a -> Parser i [a] Source #
MonadPlus m => Alternative ( WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedMonad m a Source # (<\|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source # some :: WrappedMonad m a -> WrappedMonad m [a] Source # many :: WrappedMonad m a -> WrappedMonad m [a] Source #
ArrowPlus a => Alternative ( ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods empty :: ArrowMonad a a0 Source # (<\|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source # some :: ArrowMonad a a0 -> ArrowMonad a [a0] Source # many :: ArrowMonad a a0 -> ArrowMonad a [a0] Source #
Alternative ( Proxy :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a Source # (<\|>) :: Proxy a -> Proxy a -> Proxy a Source # some :: Proxy a -> Proxy [a] Source # many :: Proxy a -> Proxy [a] Source #
Applicative m => Alternative ( ListT m)
Instance details Defined in Control.Monad.Trans.List Methods empty :: ListT m a Source # (<\|>) :: ListT m a -> ListT m a -> ListT m a Source # some :: ListT m a -> ListT m [a] Source # many :: ListT m a -> ListT m [a] Source #
( Functor m, Monad m) => Alternative ( MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a Source # (<\|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a Source # some :: MaybeT m a -> MaybeT m [a] Source # many :: MaybeT m a -> MaybeT m [a] Source #
Alternative f => Alternative ( Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: Rec1 f a Source # (<\|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a Source # some :: Rec1 f a -> Rec1 f [a] Source # many :: Rec1 f a -> Rec1 f [a] Source #
( ArrowZero a, ArrowPlus a) => Alternative ( WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 Source # (<\|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 Source # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source #
Alternative m => Alternative ( Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods empty :: Kleisli m a a0 Source # (<\|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Source # some :: Kleisli m a a0 -> Kleisli m a [a0] Source # many :: Kleisli m a a0 -> Kleisli m a [a0] Source #
Alternative f => Alternative ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods empty :: Ap f a Source # (<\|>) :: Ap f a -> Ap f a -> Ap f a Source # some :: Ap f a -> Ap f [a] Source # many :: Ap f a -> Ap f [a] Source #
Alternative f => Alternative ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods empty :: Alt f a Source # (<\|>) :: Alt f a -> Alt f a -> Alt f a Source # some :: Alt f a -> Alt f [a] Source # many :: Alt f a -> Alt f [a] Source #
Alternative m => Alternative ( IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods empty :: IdentityT m a Source # (<\|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a Source # some :: IdentityT m a -> IdentityT m [a] Source # many :: IdentityT m a -> IdentityT m [a] Source #
( Functor m, Monad m, Error e) => Alternative ( ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods empty :: ErrorT e m a Source # (<\|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source # some :: ErrorT e m a -> ErrorT e m [a] Source # many :: ErrorT e m a -> ErrorT e m [a] Source #
( Functor m, Monad m, Monoid e) => Alternative ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a Source # (<\|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source # some :: ExceptT e m a -> ExceptT e m [a] Source # many :: ExceptT e m a -> ExceptT e m [a] Source #
Alternative m => Alternative ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a Source # (<\|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a Source # some :: ReaderT r m a -> ReaderT r m [a] Source # many :: ReaderT r m a -> ReaderT r m [a] Source #
( Functor m, MonadPlus m) => Alternative ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods empty :: StateT s m a Source # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a Source # some :: StateT s m a -> StateT s m [a] Source # many :: StateT s m a -> StateT s m [a] Source #
( Functor m, MonadPlus m) => Alternative ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods empty :: StateT s m a Source # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a Source # some :: StateT s m a -> StateT s m [a] Source # many :: StateT s m a -> StateT s m [a] Source #
( Monoid w, Alternative m) => Alternative ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods empty :: WriterT w m a Source # (<\|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a Source # some :: WriterT w m a -> WriterT w m [a] Source # many :: WriterT w m a -> WriterT w m [a] Source #
( Monoid w, Alternative m) => Alternative ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods empty :: WriterT w m a Source # (<\|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a Source # some :: WriterT w m a -> WriterT w m [a] Source # many :: WriterT w m a -> WriterT w m [a] Source #
( Alternative f, Alternative g) => Alternative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :: g) a Source # (<\|>) :: (f :: g) a -> (f :: g) a -> (f :: g) a Source # some :: (f :: g) a -> (f :: g) [a] Source # many :: (f :: g) a -> (f :: g) [a] Source #
( Alternative f, Alternative g) => Alternative ( Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods empty :: Product f g a Source # (<\|>) :: Product f g a -> Product f g a -> Product f g a Source # some :: Product f g a -> Product f g [a] Source # many :: Product f g a -> Product f g [a] Source #
Alternative f => Alternative ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: M1 i c f a Source # (<\|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a Source # some :: M1 i c f a -> M1 i c f [a] Source # many :: M1 i c f a -> M1 i c f [a] Source #
( Alternative f, Applicative g) => Alternative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :.: g) a Source # (<\|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a Source # some :: (f :.: g) a -> (f :.: g) [a] Source # many :: (f :.: g) a -> (f :.: g) [a] Source #
( Alternative f, Applicative g) => Alternative ( Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a Source # (<\|>) :: Compose f g a -> Compose f g a -> Compose f g a Source # some :: Compose f g a -> Compose f g [a] Source # many :: Compose f g a -> Compose f g [a] Source #
( Monoid w, Functor m, MonadPlus m) => Alternative ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods empty :: RWST r w s m a Source # (<\|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source # some :: RWST r w s m a -> RWST r w s m [a] Source # many :: RWST r w s m a -> RWST r w s m [a] Source #
( Monoid w, Functor m, MonadPlus m) => Alternative ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods empty :: RWST r w s m a Source # (<\|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source # some :: RWST r w s m a -> RWST r w s m [a] Source # many :: RWST r w s m a -> RWST r w s m [a] Source #

class ( Alternative m, Monad m) => MonadPlus (m :: Type -> Type ) where Source #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a Source #

The identity of mplus . It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

The default definition is

mzero = empty

mplus :: m a -> m a -> m a Source #

An associative operation. The default definition is

mplus = (<|>)

Instances

Instances details

MonadPlus []	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: [a] Source # mplus :: [a] -> [a] -> [a] Source #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a Source # mplus :: Maybe a -> Maybe a -> Maybe a Source #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a Source # mplus :: IO a -> IO a -> IO a Source #
MonadPlus IResult
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: IResult a Source # mplus :: IResult a -> IResult a -> IResult a Source #
MonadPlus Result
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: Result a Source # mplus :: Result a -> Result a -> Result a Source #
MonadPlus Parser
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: Parser a Source # mplus :: Parser a -> Parser a -> Parser a Source #
MonadPlus Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mzero :: Option a Source # mplus :: Option a -> Option a -> Option a Source #
MonadPlus STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods mzero :: STM a Source # mplus :: STM a -> STM a -> STM a Source #
MonadPlus ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: ReadP a Source # mplus :: ReadP a -> ReadP a -> ReadP a Source #
MonadPlus Seq
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a Source # mplus :: Seq a -> Seq a -> Seq a Source #
MonadPlus DList
Instance details Defined in Data.DList.Internal Methods mzero :: DList a Source # mplus :: DList a -> DList a -> DList a Source #
MonadPlus SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods mzero :: SmallArray a Source # mplus :: SmallArray a -> SmallArray a -> SmallArray a Source #
MonadPlus Array
Instance details Defined in Data.Primitive.Array Methods mzero :: Array a Source # mplus :: Array a -> Array a -> Array a Source #
MonadPlus Vector
Instance details Defined in Data.Vector Methods mzero :: Vector a Source # mplus :: Vector a -> Vector a -> Vector a Source #
MonadPlus P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: P a Source # mplus :: P a -> P a -> P a Source #
MonadPlus ( U1 :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: U1 a Source # mplus :: U1 a -> U1 a -> U1 a Source #
MonadPlus ( Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods mzero :: Parser i a Source # mplus :: Parser i a -> Parser i a -> Parser i a Source #
( ArrowApply a, ArrowPlus a) => MonadPlus ( ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods mzero :: ArrowMonad a a0 Source # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source #
MonadPlus ( Proxy :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods mzero :: Proxy a Source # mplus :: Proxy a -> Proxy a -> Proxy a Source #
Monad m => MonadPlus ( ListT m)
Instance details Defined in Control.Monad.Trans.List Methods mzero :: ListT m a Source # mplus :: ListT m a -> ListT m a -> ListT m a Source #
Monad m => MonadPlus ( MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a Source # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a Source #
MonadPlus f => MonadPlus ( Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: Rec1 f a Source # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a Source #
MonadPlus m => MonadPlus ( Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods mzero :: Kleisli m a a0 Source # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Source #
MonadPlus f => MonadPlus ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mzero :: Ap f a Source # mplus :: Ap f a -> Ap f a -> Ap f a Source #
MonadPlus f => MonadPlus ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mzero :: Alt f a Source # mplus :: Alt f a -> Alt f a -> Alt f a Source #
MonadPlus m => MonadPlus ( IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a Source # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a Source #
( Monad m, Error e) => MonadPlus ( ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods mzero :: ErrorT e m a Source # mplus :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source #
( Monad m, Monoid e) => MonadPlus ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a Source # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source #
MonadPlus m => MonadPlus ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a Source # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a Source #
MonadPlus m => MonadPlus ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a Source # mplus :: StateT s m a -> StateT s m a -> StateT s m a Source #
MonadPlus m => MonadPlus ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a Source # mplus :: StateT s m a -> StateT s m a -> StateT s m a Source #
( Monoid w, MonadPlus m) => MonadPlus ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods mzero :: WriterT w m a Source # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a Source #
( Monoid w, MonadPlus m) => MonadPlus ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods mzero :: WriterT w m a Source # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a Source #
( MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: (f :: g) a Source # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a Source #
( MonadPlus f, MonadPlus g) => MonadPlus ( Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods mzero :: Product f g a Source # mplus :: Product f g a -> Product f g a -> Product f g a Source #
MonadPlus f => MonadPlus ( M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: M1 i c f a Source # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a Source #
( Monoid w, MonadPlus m) => MonadPlus ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods mzero :: RWST r w s m a Source # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source #
( Monoid w, MonadPlus m) => MonadPlus ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods mzero :: RWST r w s m a Source # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source #

phase :: RealFloat a => Complex a -> a Source #

The phase of a complex number, in the range (- pi , pi ] . If the magnitude is zero, then so is the phase.

magnitude :: RealFloat a => Complex a -> a Source #

The nonnegative magnitude of a complex number.

polar :: RealFloat a => Complex a -> (a, a) Source #

The function polar takes a complex number and returns a (magnitude, phase) pair in canonical form: the magnitude is nonnegative, and the phase in the range (- pi , pi ] ; if the magnitude is zero, then so is the phase.

cis :: Floating a => a -> Complex a Source #

cis t is a complex value with magnitude 1 and phase t (modulo 2* pi ).

mkPolar :: Floating a => a -> a -> Complex a Source #

Form a complex number from polar components of magnitude and phase.

conjugate :: Num a => Complex a -> Complex a Source #

The conjugate of a complex number.

imagPart :: Complex a -> a Source #

Extracts the imaginary part of a complex number.

realPart :: Complex a -> a Source #

Extracts the real part of a complex number.

data Complex a Source #

Complex numbers are an algebraic type.

For a complex number z , abs z is a number with the magnitude of z , but oriented in the positive real direction, whereas signum z has the phase of z , but unit magnitude.

The Foldable and Traversable instances traverse the real part first.

Note that Complex 's instances inherit the deficiencies from the type parameter's. For example, Complex Float 's Ord instance has similar problems to Float 's.

Constructors

!a :+ !a infix 6

forms a complex number from its real and imaginary rectangular components.

Instances

Instances details

Monad Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b Source # (>>) :: Complex a -> Complex b -> Complex b Source # return :: a -> Complex a Source #
Functor Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods fmap :: (a -> b) -> Complex a -> Complex b Source # (<$) :: a -> Complex b -> Complex a Source #
Applicative Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods pure :: a -> Complex a Source # (<>) :: Complex (a -> b) -> Complex a -> Complex b Source # liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c Source # (>) :: Complex a -> Complex b -> Complex b Source # (<*) :: Complex a -> Complex b -> Complex a Source #
Foldable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m Source # foldMap :: Monoid m => (a -> m) -> Complex a -> m Source # foldMap' :: Monoid m => (a -> m) -> Complex a -> m Source # foldr :: (a -> b -> b) -> b -> Complex a -> b Source # foldr' :: (a -> b -> b) -> b -> Complex a -> b Source # foldl :: (b -> a -> b) -> b -> Complex a -> b Source # foldl' :: (b -> a -> b) -> b -> Complex a -> b Source # foldr1 :: (a -> a -> a) -> Complex a -> a Source # foldl1 :: (a -> a -> a) -> Complex a -> a Source # toList :: Complex a -> [a] Source # null :: Complex a -> Bool Source # length :: Complex a -> Int Source # elem :: Eq a => a -> Complex a -> Bool Source # maximum :: Ord a => Complex a -> a Source # minimum :: Ord a => Complex a -> a Source # sum :: Num a => Complex a -> a Source # product :: Num a => Complex a -> a Source #
Traversable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f ( Complex b) Source # sequenceA :: Applicative f => Complex (f a) -> f ( Complex a) Source # mapM :: Monad m => (a -> m b) -> Complex a -> m ( Complex b) Source # sequence :: Monad m => Complex (m a) -> m ( Complex a) Source #
Hashable1 Complex
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Complex a -> Int Source #
Unbox a => Vector Vector ( Complex a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Complex a) -> m ( Vector ( Complex a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Complex a) -> m ( Mutable Vector ( PrimState m) ( Complex a)) Source # basicLength :: Vector ( Complex a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Complex a) -> Vector ( Complex a) Source # basicUnsafeIndexM :: Monad m => Vector ( Complex a) -> Int -> m ( Complex a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Complex a) -> Vector ( Complex a) -> m () Source # elemseq :: Vector ( Complex a) -> Complex a -> b -> b Source #
Unbox a => MVector MVector ( Complex a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Complex a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Complex a) -> MVector s ( Complex a) Source # basicOverlaps :: MVector s ( Complex a) -> MVector s ( Complex a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Complex a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m ( MVector ( PrimState m) ( Complex a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Int -> m ( Complex a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Int -> Complex a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Complex a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> MVector ( PrimState m) ( Complex a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> MVector ( PrimState m) ( Complex a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Int -> m ( MVector ( PrimState m) ( Complex a)) Source #
Eq a => Eq ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (==) :: Complex a -> Complex a -> Bool Source # (/=) :: Complex a -> Complex a -> Bool Source #
RealFloat a => Floating ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods pi :: Complex a Source # exp :: Complex a -> Complex a Source # log :: Complex a -> Complex a Source # sqrt :: Complex a -> Complex a Source # (**) :: Complex a -> Complex a -> Complex a Source # logBase :: Complex a -> Complex a -> Complex a Source # sin :: Complex a -> Complex a Source # cos :: Complex a -> Complex a Source # tan :: Complex a -> Complex a Source # asin :: Complex a -> Complex a Source # acos :: Complex a -> Complex a Source # atan :: Complex a -> Complex a Source # sinh :: Complex a -> Complex a Source # cosh :: Complex a -> Complex a Source # tanh :: Complex a -> Complex a Source # asinh :: Complex a -> Complex a Source # acosh :: Complex a -> Complex a Source # atanh :: Complex a -> Complex a Source # log1p :: Complex a -> Complex a Source # expm1 :: Complex a -> Complex a Source # log1pexp :: Complex a -> Complex a Source # log1mexp :: Complex a -> Complex a Source #
RealFloat a => Fractional ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (/) :: Complex a -> Complex a -> Complex a Source # recip :: Complex a -> Complex a Source # fromRational :: Rational -> Complex a Source #
Data a => Data ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Complex a -> c ( Complex a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Complex a) Source # toConstr :: Complex a -> Constr Source # dataTypeOf :: Complex a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Complex a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Complex a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Complex a -> Complex a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Complex a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Complex a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Complex a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Complex a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Complex a -> m ( Complex a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Complex a -> m ( Complex a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Complex a -> m ( Complex a) Source #
RealFloat a => Num ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (+) :: Complex a -> Complex a -> Complex a Source # (-) :: Complex a -> Complex a -> Complex a Source # (*) :: Complex a -> Complex a -> Complex a Source # negate :: Complex a -> Complex a Source # abs :: Complex a -> Complex a Source # signum :: Complex a -> Complex a Source # fromInteger :: Integer -> Complex a Source #
Read a => Read ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods readsPrec :: Int -> ReadS ( Complex a) Source # readList :: ReadS [ Complex a] Source # readPrec :: ReadPrec ( Complex a) Source # readListPrec :: ReadPrec [ Complex a] Source #
Show a => Show ( Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods showsPrec :: Int -> Complex a -> ShowS Source # show :: Complex a -> String Source # showList :: [ Complex a] -> ShowS Source #
Generic ( Complex a)	Since: base-4.9.0.0
Instance details Defined in Data.Complex Associated Types type Rep ( Complex a) :: Type -> Type Source # Methods from :: Complex a -> Rep ( Complex a) x Source # to :: Rep ( Complex a) x -> Complex a Source #
Hashable a => Hashable ( Complex a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Complex a -> Int Source # hash :: Complex a -> Int Source #
Storable a => Storable ( Complex a)	Since: base-4.8.0.0
Instance details Defined in Data.Complex Methods sizeOf :: Complex a -> Int Source # alignment :: Complex a -> Int Source # peekElemOff :: Ptr ( Complex a) -> Int -> IO ( Complex a) Source # pokeElemOff :: Ptr ( Complex a) -> Int -> Complex a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Complex a) Source # pokeByteOff :: Ptr b -> Int -> Complex a -> IO () Source # peek :: Ptr ( Complex a) -> IO ( Complex a) Source # poke :: Ptr ( Complex a) -> Complex a -> IO () Source #
NFData a => NFData ( Complex a)
Instance details Defined in Control.DeepSeq Methods rnf :: Complex a -> () Source #
Unbox a => Unbox ( Complex a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Associated Types type Rep1 Complex :: k -> Type Source # Methods from1 :: forall (a :: k). Complex a -> Rep1 Complex a Source # to1 :: forall (a :: k). Rep1 Complex a -> Complex a Source #
newtype MVector s ( Complex a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Complex a) = MV_Complex ( MVector s (a, a))
type Rep ( Complex a)
Instance details Defined in Data.Complex type Rep ( Complex a) = D1 (' MetaData "Complex" "Data.Complex" "base" ' False ) ( C1 (' MetaCons ":+" (' InfixI ' NotAssociative 6) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 a)))
newtype Vector ( Complex a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Complex a) = V_Complex ( Vector (a, a))
type Rep1 Complex
Instance details Defined in Data.Complex type Rep1 Complex = D1 (' MetaData "Complex" "Data.Complex" "base" ' False ) ( C1 (' MetaCons ":+" (' InfixI ' NotAssociative 6) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) Par1 :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) Par1 ))

vacuous :: Functor f => f Void -> f a Source #

If Void is uninhabited then any Functor that holds only values of type Void is holding no values.

Using ApplicativeDo : ' vacuous theVoid ' can be understood as the do expression

do void <- theVoid
   pure (absurd void)

with an inferred Functor constraint.

Since: base-4.8.0.0

absurd :: Void -> a Source #

Since Void values logically don't exist, this witnesses the logical reasoning tool of "ex falso quodlibet".

>>> let x :: Either Void Int; x = Right 5
>>> :{
case x of
    Right r -> r
    Left l  -> absurd l
:}
5

Since: base-4.8.0.0

data Void Source #

Uninhabited data type

Since: base-4.8.0.0

Instances

Instances details

Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool Source # (/=) :: Void -> Void -> Bool Source #
Data Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Void -> c Void Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c Void Source # toConstr :: Void -> Constr Source # dataTypeOf :: Void -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c Void ) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c Void ) Source # gmapT :: ( forall b. Data b => b -> b) -> Void -> Void Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Void -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Void -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Void -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Void -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Void -> m Void Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Void -> m Void Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Void -> m Void Source #
Ord Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods compare :: Void -> Void -> Ordering Source # (<) :: Void -> Void -> Bool Source # (<=) :: Void -> Void -> Bool Source # (>) :: Void -> Void -> Bool Source # (>=) :: Void -> Void -> Bool Source # max :: Void -> Void -> Void Source # min :: Void -> Void -> Void Source #
Read Void	Reading a `Void` value is always a parse error, considering `Void` as a data type with no constructors. Since: base-4.8.0.0
Instance details Defined in Data.Void Methods readsPrec :: Int -> ReadS Void Source # readList :: ReadS [ Void ] Source # readPrec :: ReadPrec Void Source # readListPrec :: ReadPrec [ Void ] Source #
Show Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods showsPrec :: Int -> Void -> ShowS Source # show :: Void -> String Source # showList :: [ Void ] -> ShowS Source #
Ix Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods range :: ( Void , Void ) -> [ Void ] Source # index :: ( Void , Void ) -> Void -> Int Source # unsafeIndex :: ( Void , Void ) -> Void -> Int Source # inRange :: ( Void , Void ) -> Void -> Bool Source # rangeSize :: ( Void , Void ) -> Int Source # unsafeRangeSize :: ( Void , Void ) -> Int Source #
Generic Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type Source # Methods from :: Void -> Rep Void x Source # to :: Rep Void x -> Void Source #
Semigroup Void	Since: base-4.9.0.0
Instance details Defined in Data.Void Methods (<>) :: Void -> Void -> Void Source # sconcat :: NonEmpty Void -> Void Source # stimes :: Integral b => b -> Void -> Void Source #
Hashable Void
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Void -> Int Source # hash :: Void -> Int Source #
Exception Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods toException :: Void -> SomeException Source # fromException :: SomeException -> Maybe Void Source # displayException :: Void -> String Source #
NFData Void	Defined as `rnf = absurd` . Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Void -> () Source #
Buildable Void
Instance details Defined in Formatting.Buildable Methods build :: Void -> Builder Source #
Lift Void	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Void -> Q Exp Source # liftTyped :: Void -> Q ( TExp Void ) Source #
type Rep Void
Instance details Defined in Data.Void type Rep Void = D1 (' MetaData "Void" "Data.Void" "base" ' False ) ( V1 :: Type -> Type )

option :: b -> (a -> b) -> Option a -> b Source #

Fold an Option case-wise, just like maybe .

mtimesDefault :: ( Integral b, Monoid a) => b -> a -> a Source #

Repeat a value n times.

mtimesDefault n a = a <> a <> ... <> a  -- using <> (n-1) times

Implemented using stimes and mempty .

This is a suitable definition for an mtimes member of Monoid .

diff :: Semigroup m => m -> Endo m Source #

This lets you use a difference list of a Semigroup as a Monoid .

cycle1 :: Semigroup m => m -> m Source #

A generalization of cycle to an arbitrary Semigroup . May fail to terminate for some values in some semigroups.

data WrappedMonoid m Source #

Provide a Semigroup for an arbitrary Monoid.

NOTE : This is not needed anymore since Semigroup became a superclass of Monoid in base-4.11 and this newtype be deprecated at some point in the future.

Instances

Instances details

NFData1 WrappedMonoid	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> WrappedMonoid a -> () Source #
Hashable1 WrappedMonoid	Since: hashable-1.3.1.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> WrappedMonoid a -> Int Source #
Unbox a => Vector Vector ( WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( WrappedMonoid a) -> m ( Vector ( WrappedMonoid a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( WrappedMonoid a) -> m ( Mutable Vector ( PrimState m) ( WrappedMonoid a)) Source # basicLength :: Vector ( WrappedMonoid a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( WrappedMonoid a) -> Vector ( WrappedMonoid a) Source # basicUnsafeIndexM :: Monad m => Vector ( WrappedMonoid a) -> Int -> m ( WrappedMonoid a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( WrappedMonoid a) -> Vector ( WrappedMonoid a) -> m () Source # elemseq :: Vector ( WrappedMonoid a) -> WrappedMonoid a -> b -> b Source #
Unbox a => MVector MVector ( WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( WrappedMonoid a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( WrappedMonoid a) -> MVector s ( WrappedMonoid a) Source # basicOverlaps :: MVector s ( WrappedMonoid a) -> MVector s ( WrappedMonoid a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( WrappedMonoid a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> WrappedMonoid a -> m ( MVector ( PrimState m) ( WrappedMonoid a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> Int -> m ( WrappedMonoid a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> Int -> WrappedMonoid a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> WrappedMonoid a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> Int -> m ( MVector ( PrimState m) ( WrappedMonoid a)) Source #
Bounded m => Bounded ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m Source # maxBound :: WrappedMonoid m Source #
Enum a => Enum ( WrappedMonoid a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a Source # pred :: WrappedMonoid a -> WrappedMonoid a Source # toEnum :: Int -> WrappedMonoid a Source # fromEnum :: WrappedMonoid a -> Int Source # enumFrom :: WrappedMonoid a -> [ WrappedMonoid a] Source # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [ WrappedMonoid a] Source # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [ WrappedMonoid a] Source # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [ WrappedMonoid a] Source #
Eq m => Eq ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source #
Data m => Data ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> WrappedMonoid m -> c ( WrappedMonoid m) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( WrappedMonoid m) Source # toConstr :: WrappedMonoid m -> Constr Source # dataTypeOf :: WrappedMonoid m -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( WrappedMonoid m)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( WrappedMonoid m)) Source # gmapT :: ( forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> WrappedMonoid m -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> WrappedMonoid m -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> WrappedMonoid m -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> WrappedMonoid m -> u Source # gmapM :: Monad m0 => ( forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 ( WrappedMonoid m) Source # gmapMp :: MonadPlus m0 => ( forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 ( WrappedMonoid m) Source # gmapMo :: MonadPlus m0 => ( forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 ( WrappedMonoid m) Source #
Ord m => Ord ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering Source # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source #
Read m => Read ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( WrappedMonoid m) Source # readList :: ReadS [ WrappedMonoid m] Source # readPrec :: ReadPrec ( WrappedMonoid m) Source # readListPrec :: ReadPrec [ WrappedMonoid m] Source #
Show m => Show ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> WrappedMonoid m -> ShowS Source # show :: WrappedMonoid m -> String Source # showList :: [ WrappedMonoid m] -> ShowS Source #
Generic ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( WrappedMonoid m) :: Type -> Type Source # Methods from :: WrappedMonoid m -> Rep ( WrappedMonoid m) x Source # to :: Rep ( WrappedMonoid m) x -> WrappedMonoid m Source #
Monoid m => Semigroup ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # sconcat :: NonEmpty ( WrappedMonoid m) -> WrappedMonoid m Source # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m Source #
Monoid m => Monoid ( WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: WrappedMonoid m Source # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # mconcat :: [ WrappedMonoid m] -> WrappedMonoid m Source #
Hashable a => Hashable ( WrappedMonoid a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WrappedMonoid a -> Int Source # hash :: WrappedMonoid a -> Int Source #
NFData m => NFData ( WrappedMonoid m)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: WrappedMonoid m -> () Source #
Unbox a => Unbox ( WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 WrappedMonoid	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 WrappedMonoid :: k -> Type Source # Methods from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a Source # to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a Source #
newtype MVector s ( WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( WrappedMonoid a) = MV_WrappedMonoid ( MVector s a)
type Rep ( WrappedMonoid m)
Instance details Defined in Data.Semigroup type Rep ( WrappedMonoid m) = D1 (' MetaData "WrappedMonoid" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "WrapMonoid" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unwrapMonoid") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 m)))
newtype Vector ( WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( WrappedMonoid a) = V_WrappedMonoid ( Vector a)
type Rep1 WrappedMonoid
Instance details Defined in Data.Semigroup type Rep1 WrappedMonoid = D1 (' MetaData "WrappedMonoid" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "WrapMonoid" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "unwrapMonoid") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 ))

newtype Option a Source #

Option is effectively Maybe with a better instance of Monoid , built off of an underlying Semigroup instead of an underlying Monoid .

Ideally, this type would not exist at all and we would just fix the Monoid instance of Maybe .

In GHC 8.4 and higher, the Monoid instance for Maybe has been corrected to lift a Semigroup instance instead of a Monoid instance. Consequently, this type is no longer useful. It will be marked deprecated in GHC 8.8 and removed in GHC 8.10.

Constructors

Option
Fields getOption :: Maybe a

Instances

Instances details

Monad Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Option a -> (a -> Option b) -> Option b Source # (>>) :: Option a -> Option b -> Option b Source # return :: a -> Option a Source #
Functor Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Option a -> Option b Source # (<$) :: a -> Option b -> Option a Source #
MonadFix Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mfix :: (a -> Option a) -> Option a Source #
Applicative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Option a Source # (<>) :: Option (a -> b) -> Option a -> Option b Source # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c Source # (>) :: Option a -> Option b -> Option b Source # (<*) :: Option a -> Option b -> Option a Source #
Foldable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m Source # foldMap :: Monoid m => (a -> m) -> Option a -> m Source # foldMap' :: Monoid m => (a -> m) -> Option a -> m Source # foldr :: (a -> b -> b) -> b -> Option a -> b Source # foldr' :: (a -> b -> b) -> b -> Option a -> b Source # foldl :: (b -> a -> b) -> b -> Option a -> b Source # foldl' :: (b -> a -> b) -> b -> Option a -> b Source # foldr1 :: (a -> a -> a) -> Option a -> a Source # foldl1 :: (a -> a -> a) -> Option a -> a Source # toList :: Option a -> [a] Source # null :: Option a -> Bool Source # length :: Option a -> Int Source # elem :: Eq a => a -> Option a -> Bool Source # maximum :: Ord a => Option a -> a Source # minimum :: Ord a => Option a -> a Source # sum :: Num a => Option a -> a Source # product :: Num a => Option a -> a Source #
Traversable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Option a -> f ( Option b) Source # sequenceA :: Applicative f => Option (f a) -> f ( Option a) Source # mapM :: Monad m => (a -> m b) -> Option a -> m ( Option b) Source # sequence :: Monad m => Option (m a) -> m ( Option a) Source #
Alternative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods empty :: Option a Source # (<\|>) :: Option a -> Option a -> Option a Source # some :: Option a -> Option [a] Source # many :: Option a -> Option [a] Source #
MonadPlus Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mzero :: Option a Source # mplus :: Option a -> Option a -> Option a Source #
NFData1 Option	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Option a -> () Source #
Hashable1 Option	Since: hashable-1.3.1.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Option a -> Int Source #
Eq a => Eq ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Option a -> Option a -> Bool Source # (/=) :: Option a -> Option a -> Bool Source #
Data a => Data ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Option a -> c ( Option a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Option a) Source # toConstr :: Option a -> Constr Source # dataTypeOf :: Option a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Option a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Option a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Option a -> Option a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Option a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Option a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Option a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Option a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Option a -> m ( Option a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Option a -> m ( Option a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Option a -> m ( Option a) Source #
Ord a => Ord ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Option a -> Option a -> Ordering Source # (<) :: Option a -> Option a -> Bool Source # (<=) :: Option a -> Option a -> Bool Source # (>) :: Option a -> Option a -> Bool Source # (>=) :: Option a -> Option a -> Bool Source # max :: Option a -> Option a -> Option a Source # min :: Option a -> Option a -> Option a Source #
Read a => Read ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS ( Option a) Source # readList :: ReadS [ Option a] Source # readPrec :: ReadPrec ( Option a) Source # readListPrec :: ReadPrec [ Option a] Source #
Show a => Show ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Option a -> ShowS Source # show :: Option a -> String Source # showList :: [ Option a] -> ShowS Source #
Generic ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep ( Option a) :: Type -> Type Source # Methods from :: Option a -> Rep ( Option a) x Source # to :: Rep ( Option a) x -> Option a Source #
Semigroup a => Semigroup ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Option a -> Option a -> Option a Source # sconcat :: NonEmpty ( Option a) -> Option a Source # stimes :: Integral b => b -> Option a -> Option a Source #
Semigroup a => Monoid ( Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Option a Source # mappend :: Option a -> Option a -> Option a Source # mconcat :: [ Option a] -> Option a Source #
Hashable a => Hashable ( Option a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Option a -> Int Source # hash :: Option a -> Int Source #
NFData a => NFData ( Option a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Option a -> () Source #
Generic1 Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Option :: k -> Type Source # Methods from1 :: forall (a :: k). Option a -> Rep1 Option a Source # to1 :: forall (a :: k). Rep1 Option a -> Option a Source #
type Rep ( Option a)
Instance details Defined in Data.Semigroup type Rep ( Option a) = D1 (' MetaData "Option" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "Option" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getOption") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe a))))
type Rep1 Option
Instance details Defined in Data.Semigroup type Rep1 Option = D1 (' MetaData "Option" "Data.Semigroup" "base" ' True ) ( C1 (' MetaCons "Option" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getOption") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 Maybe )))

threadWaitWriteSTM :: Fd -> IO ( STM (), IO ()) Source #

Returns an STM action that can be used to wait until data can be written to a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.

Since: base-4.7.0.0

threadWaitReadSTM :: Fd -> IO ( STM (), IO ()) Source #

Returns an STM action that can be used to wait for data to read from a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.

Since: base-4.7.0.0

threadWaitWrite :: Fd -> IO () Source #

Block the current thread until data can be written to the given file descriptor (GHC only).

This will throw an IOError if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with threadWaitWrite , use closeFdWith .

threadWaitRead :: Fd -> IO () Source #

Block the current thread until data is available to read on the given file descriptor (GHC only).

This will throw an IOError if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with threadWaitRead , use closeFdWith .

runInUnboundThread :: IO a -> IO a Source #

Run the IO computation passed as the first argument. If the calling thread is bound , an unbound thread is created temporarily using forkIO . runInBoundThread doesn't finish until the IO computation finishes.

Use this function only in the rare case that you have actually observed a performance loss due to the use of bound threads. A program that doesn't need its main thread to be bound and makes heavy use of concurrency (e.g. a web server), might want to wrap its main action in runInUnboundThread .

Note that exceptions which are thrown to the current thread are thrown in turn to the thread that is executing the given computation. This ensures there's always a way of killing the forked thread.

runInBoundThread :: IO a -> IO a Source #

Run the IO computation passed as the first argument. If the calling thread is not bound , a bound thread is created temporarily. runInBoundThread doesn't finish until the IO computation finishes.

You can wrap a series of foreign function calls that rely on thread-local state with runInBoundThread so that you can use them without knowing whether the current thread is bound .

isCurrentThreadBound :: IO Bool Source #

Returns True if the calling thread is bound , that is, if it is safe to use foreign libraries that rely on thread-local state from the calling thread.

forkOSWithUnmask :: (( forall a. IO a -> IO a) -> IO ()) -> IO ThreadId Source #

Like forkIOWithUnmask , but the child thread is a bound thread, as with forkOS .

forkFinally :: IO a -> ( Either SomeException a -> IO ()) -> IO ThreadId Source #

Fork a thread and call the supplied function when the thread is about to terminate, with an exception or a returned value. The function is called with asynchronous exceptions masked.

forkFinally action and_then =
  mask $ \restore ->
    forkIO $ try (restore action) >>= and_then

This function is useful for informing the parent when a child terminates, for example.

Since: base-4.6.0.0

rtsSupportsBoundThreads :: Bool Source #

True if bound threads are supported. If rtsSupportsBoundThreads is False , isCurrentThreadBound will always return False and both forkOS and runInBoundThread will fail.

writeList2Chan :: Chan a -> [a] -> IO () Source #

Write an entire list of items to a Chan .

getChanContents :: Chan a -> IO [a] Source #

Return a lazy list representing the contents of the supplied Chan , much like hGetContents .

dupChan :: Chan a -> IO ( Chan a) Source #

Duplicate a Chan : the duplicate channel begins empty, but data written to either channel from then on will be available from both. Hence this creates a kind of broadcast channel, where data written by anyone is seen by everyone else.

(Note that a duplicated channel is not equal to its original. So: fmap (c /=) $ dupChan c returns True for all c .)

readChan :: Chan a -> IO a Source #

Read the next value from the Chan . Blocks when the channel is empty. Since the read end of a channel is an MVar , this operation inherits fairness guarantees of MVar s (e.g. threads blocked in this operation are woken up in FIFO order).

Throws BlockedIndefinitelyOnMVar when the channel is empty and no other thread holds a reference to the channel.

writeChan :: Chan a -> a -> IO () Source #

Write a value to a Chan .

newChan :: IO ( Chan a) Source #

Build and returns a new instance of Chan .

data Chan a Source #

Chan is an abstract type representing an unbounded FIFO channel.

Instances

Instances details

Eq ( Chan a)	Since: base-4.4.0.0
Instance details Defined in Control.Concurrent.Chan Methods (==) :: Chan a -> Chan a -> Bool Source # (/=) :: Chan a -> Chan a -> Bool Source #

signalQSem :: QSem -> IO () Source #

Signal that a unit of the QSem is available

waitQSem :: QSem -> IO () Source #

Wait for a unit to become available

newQSem :: Int -> IO QSem Source #

Build a new QSem with a supplied initial quantity. The initial quantity must be at least 0.

data QSem Source #

QSem is a quantity semaphore in which the resource is acquired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked waitQSem calls.

The pattern

  bracket_ waitQSem signalQSem (...)

is safe; it never loses a unit of the resource.

signalQSemN :: QSemN -> Int -> IO () Source #

Signal that a given quantity is now available from the QSemN .

waitQSemN :: QSemN -> Int -> IO () Source #

Wait for the specified quantity to become available

newQSemN :: Int -> IO QSemN Source #

Build a new QSemN with a supplied initial quantity. The initial quantity must be at least 0.

data QSemN Source #

QSemN is a quantity semaphore in which the resource is acquired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked waitQSemN calls.

The pattern

  bracket_ (waitQSemN n) (signalQSemN n) (...)

is safe; it never loses any of the resource.

nonEmpty :: [a] -> Maybe ( NonEmpty a) Source #

nonEmpty efficiently turns a normal list into a NonEmpty stream, producing Nothing if the input is empty.

showStackTrace :: IO ( Maybe String ) Source #

Get a string representation of the current execution stack state.

getStackTrace :: IO ( Maybe [ Location ]) Source #

Get a trace of the current execution stack state.

Returns Nothing if stack trace support isn't available on host machine.

data SrcLoc Source #

A location in the original program source.

Constructors

SrcLoc String Int Int

data Location Source #

Location information about an address from a backtrace.

Constructors

Location
Fields objectName :: String functionName :: String srcLoc :: Maybe SrcLoc

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

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a Source #

Lift a computation from the IO monad.

Instances

Instances details

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a Source #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a Source #
MonadIO m => MonadIO ( ListT m)
Instance details Defined in Control.Monad.Trans.List Methods liftIO :: IO a -> ListT m a Source #
MonadIO m => MonadIO ( MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a Source #
MonadIO m => MonadIO ( IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a Source #
( Error e, MonadIO m) => MonadIO ( ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods liftIO :: IO a -> ErrorT e m a Source #
MonadIO m => MonadIO ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a Source #
MonadIO m => MonadIO ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a Source #
MonadIO m => MonadIO ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a Source #
MonadIO m => MonadIO ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a Source #
( Monoid w, MonadIO m) => MonadIO ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a Source #
( Monoid w, MonadIO m) => MonadIO ( WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a Source #
( Monoid w, MonadIO m) => MonadIO ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a Source #
( Monoid w, MonadIO m) => MonadIO ( RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a Source #

getArgs :: IO [ String ] Source #

Computation getArgs returns a list of the program's command line arguments (not including the program name).

exitSuccess :: IO a Source #

The computation exitSuccess is equivalent to exitWith ExitSuccess , It terminates the program successfully.

exitFailure :: IO a Source #

The computation exitFailure is equivalent to exitWith ( ExitFailure exitfail ) , where exitfail is implementation-dependent.

exitWith :: ExitCode -> IO a Source #

Computation exitWith code throws ExitCode code . Normally this terminates the program, returning code to the program's caller.

On program termination, the standard Handle s stdout and stderr are flushed automatically; any other buffered Handle s need to be flushed manually, otherwise the buffered data will be discarded.

A program that fails in any other way is treated as if it had called exitFailure . A program that terminates successfully without calling exitWith explicitly is treated as if it had called exitWith ExitSuccess .

As an ExitCode is not an IOError , exitWith bypasses the error handling in the IO monad and cannot be intercepted by catch from the Prelude . However it is a SomeException , and can be caught using the functions of Control.Exception . This means that cleanup computations added with bracket (from Control.Exception ) are also executed properly on exitWith .

Note: in GHC, exitWith should be called from the main program thread in order to exit the process. When called from another thread, exitWith will throw an ExitException as normal, but the exception will not cause the process itself to exit.

mfilter :: MonadPlus m => (a -> Bool ) -> m a -> m a Source #

Direct MonadPlus equivalent of filter .

Examples

Expand

The filter function is just mfilter specialized to the list monad:

filter = ( mfilter :: (a -> Bool) -> [a] -> [a] )

An example using mfilter with the Maybe monad:

>>> mfilter odd (Just 1)
Just 1
>>> mfilter odd (Just 2)
Nothing

(<$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 Source #

Strict version of <$> .

Since: base-4.8.0.0

unless :: Applicative f => Bool -> f () -> f () Source #

The reverse of when .

replicateM_ :: Applicative m => Int -> m a -> m () Source #

Like replicateM , but discards the result.

replicateM :: Applicative m => Int -> m a -> m [a] Source #

replicateM n act performs the action n times, gathering the results.

Using ApplicativeDo : ' replicateM 5 as ' can be understood as the do expression

do a1 <- as
   a2 <- as
   a3 <- as
   a4 <- as
   a5 <- as
   pure [a1,a2,a3,a4,a5]

Note the Applicative constraint.

foldM_ :: ( Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () Source #

Like foldM , but discards the result.

foldM :: ( Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b Source #

The foldM function is analogous to foldl , except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue where ( >> ) and the `folded function' are not commutative.

foldM f a1 [x1, x2, ..., xm]

==

do
  a2 <- f a1 x1
  a3 <- f a2 x2
  ...
  f am xm

If right-to-left evaluation is required, the input list should be reversed.

Note: foldM is the same as foldlM

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () Source #

zipWithM_ is the extension of zipWithM which ignores the final result.

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] Source #

The zipWithM function generalizes zipWith to arbitrary applicative functors.

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) Source #

The mapAndUnzipM function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state monad.

forever :: Applicative f => f a -> f b Source #

Repeat an action indefinitely.

Using ApplicativeDo : ' forever as ' can be understood as the pseudo- do expression

do as
   as
   ..

with as repeating.

Examples

Expand

A common use of forever is to process input from network sockets, Handle s, and channels (e.g. MVar and Chan ).

For example, here is how we might implement an echo server , using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

echoServer :: Socket -> IO ()
echoServer socket = forever $ do
  client <- accept socket
  forkFinally (echo client) (\_ -> hClose client)
  where
    echo :: Handle -> IO ()
    echo client = forever $
      hGetLine client >>= hPutStrLn client

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 Source #

Right-to-left composition of Kleisli arrows. ( >=> ) , with the arguments flipped.

Note how this operator resembles function composition ( . ) :

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Source #

Left-to-right composition of Kleisli arrows.

' (bs >=> cs) a ' can be understood as the do expression

do b <- bs a
   cs b

filterM :: Applicative m => (a -> m Bool ) -> [a] -> m [a] Source #

This generalizes the list-based filter function.

foldMapDefault :: ( Traversable t, Monoid m) => (a -> m) -> t a -> m Source #

This function may be used as a value for foldMap in a Foldable instance.

foldMapDefault f ≡ getConst . traverse (Const . f)

fmapDefault :: Traversable t => (a -> b) -> t a -> t b Source #

This function may be used as a value for fmap in a Functor instance, provided that traverse is defined. (Using fmapDefault with a Traversable instance defined only by sequenceA will result in infinite recursion.)

fmapDefault f ≡ runIdentity . traverse (Identity . f)

mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) Source #

The mapAccumR function behaves like a combination of fmap and foldr ; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure.

mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) Source #

The mapAccumL function behaves like a combination of fmap and foldl ; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.

forM :: ( Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) Source #

forM is mapM with its arguments flipped. For a version that ignores the results see forM_ .

for :: ( Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) Source #

for is traverse with its arguments flipped. For a version that ignores the results see for_ .

optional :: Alternative f => f a -> f ( Maybe a) Source #

One or none.

newtype ZipList a Source #

Lists, but with an Applicative functor based on zipping.

Constructors

ZipList
Fields getZipList :: [a]

Instances

Instances details

Functor ZipList	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b Source # (<$) :: a -> ZipList b -> ZipList a Source #
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 Source # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c Source # (>) :: ZipList a -> ZipList b -> ZipList b Source # (<*) :: ZipList a -> ZipList b -> ZipList a Source #
Foldable ZipList	Since: base-4.9.0.0
Instance details Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m Source # foldMap :: Monoid m => (a -> m) -> ZipList a -> m Source # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m Source # foldr :: (a -> b -> b) -> b -> ZipList a -> b Source # foldr' :: (a -> b -> b) -> b -> ZipList a -> b Source # foldl :: (b -> a -> b) -> b -> ZipList a -> b Source # foldl' :: (b -> a -> b) -> b -> ZipList a -> b Source # foldr1 :: (a -> a -> a) -> ZipList a -> a Source # foldl1 :: (a -> a -> a) -> ZipList a -> a Source # toList :: ZipList a -> [a] Source # null :: ZipList a -> Bool Source # length :: ZipList a -> Int Source # elem :: Eq a => a -> ZipList a -> Bool Source # maximum :: Ord a => ZipList a -> a Source # minimum :: Ord a => ZipList a -> a Source # sum :: Num a => ZipList a -> a Source # product :: Num a => ZipList a -> a Source #
Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f ( ZipList b) Source # sequenceA :: Applicative f => ZipList (f a) -> f ( ZipList a) Source # mapM :: Monad m => (a -> m b) -> ZipList a -> m ( ZipList b) Source # sequence :: Monad m => ZipList (m a) -> m ( ZipList a) Source #
Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a Source # (<\|>) :: ZipList a -> ZipList a -> ZipList a Source # some :: ZipList a -> ZipList [a] Source # many :: ZipList a -> ZipList [a] Source #
NFData1 ZipList	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> ZipList a -> () Source #
IsList ( ZipList a)	Since: base-4.15.0.0
Instance details Defined in GHC.Exts Associated Types type Item ( ZipList a) Source # Methods fromList :: [ Item ( ZipList a)] -> ZipList a Source # fromListN :: Int -> [ Item ( ZipList a)] -> ZipList a Source # toList :: ZipList a -> [ Item ( ZipList a)] Source #
Eq a => Eq ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (==) :: ZipList a -> ZipList a -> Bool Source # (/=) :: ZipList a -> ZipList a -> Bool Source #
Ord a => Ord ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods compare :: ZipList a -> ZipList a -> Ordering Source # (<) :: ZipList a -> ZipList a -> Bool Source # (<=) :: ZipList a -> ZipList a -> Bool Source # (>) :: ZipList a -> ZipList a -> Bool Source # (>=) :: ZipList a -> ZipList a -> Bool Source # max :: ZipList a -> ZipList a -> ZipList a Source # min :: ZipList a -> ZipList a -> ZipList a Source #
Read a => Read ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods readsPrec :: Int -> ReadS ( ZipList a) Source # readList :: ReadS [ ZipList a] Source # readPrec :: ReadPrec ( ZipList a) Source # readListPrec :: ReadPrec [ ZipList a] Source #
Show a => Show ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods showsPrec :: Int -> ZipList a -> ShowS Source # show :: ZipList a -> String Source # showList :: [ ZipList a] -> ShowS Source #
Generic ( ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep ( ZipList a) :: Type -> Type Source # Methods from :: ZipList a -> Rep ( ZipList a) x Source # to :: Rep ( ZipList a) x -> ZipList a Source #
NFData a => NFData ( ZipList a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ZipList a -> () Source #
Generic1 ZipList	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep1 ZipList :: k -> Type Source # Methods from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a Source # to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a Source #
type Rep ( ZipList a)
Instance details Defined in Control.Applicative type Rep ( ZipList a) = D1 (' MetaData "ZipList" "Control.Applicative" "base" ' True ) ( C1 (' MetaCons "ZipList" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getZipList") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [a])))
type Item ( ZipList a)
Instance details Defined in GHC.Exts type Item ( ZipList a) = a
type Rep1 ZipList
Instance details Defined in Control.Applicative type Rep1 ZipList = D1 (' MetaData "ZipList" "Control.Applicative" "base" ' True ) ( C1 (' MetaCons "ZipList" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getZipList") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 [])))

newtype Identity a Source #

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Constructors

Identity
Fields runIdentity :: a

Instances

Instances details

Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b Source # (>>) :: Identity a -> Identity b -> Identity b Source # return :: a -> Identity a Source #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b Source # (<$) :: a -> Identity b -> Identity a Source #
MonadFix Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a Source #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a Source # (<>) :: Identity (a -> b) -> Identity a -> Identity b Source # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source # (>) :: Identity a -> Identity b -> Identity b Source # (<*) :: Identity a -> Identity b -> Identity a Source #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m Source # foldMap :: Monoid m => (a -> m) -> Identity a -> m Source # foldMap' :: Monoid m => (a -> m) -> Identity a -> m Source # foldr :: (a -> b -> b) -> b -> Identity a -> b Source # foldr' :: (a -> b -> b) -> b -> Identity a -> b Source # foldl :: (b -> a -> b) -> b -> Identity a -> b Source # foldl' :: (b -> a -> b) -> b -> Identity a -> b Source # foldr1 :: (a -> a -> a) -> Identity a -> a Source # foldl1 :: (a -> a -> a) -> Identity a -> a Source # toList :: Identity a -> [a] Source # null :: Identity a -> Bool Source # length :: Identity a -> Int Source # elem :: Eq a => a -> Identity a -> Bool Source # maximum :: Ord a => Identity a -> a Source # minimum :: Ord a => Identity a -> a Source # sum :: Num a => Identity a -> a Source # product :: Num a => Identity a -> a Source #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f ( Identity b) Source # sequenceA :: Applicative f => Identity (f a) -> f ( Identity a) Source # mapM :: Monad m => (a -> m b) -> Identity a -> m ( Identity b) Source # sequence :: Monad m => Identity (m a) -> m ( Identity a) Source #
NFData1 Identity	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Identity a -> () Source #
Hashable1 Identity
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Identity a -> Int Source #
Unbox a => Vector Vector ( Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Identity a) -> m ( Vector ( Identity a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Identity a) -> m ( Mutable Vector ( PrimState m) ( Identity a)) Source # basicLength :: Vector ( Identity a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Identity a) -> Vector ( Identity a) Source # basicUnsafeIndexM :: Monad m => Vector ( Identity a) -> Int -> m ( Identity a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Identity a) -> Vector ( Identity a) -> m () Source # elemseq :: Vector ( Identity a) -> Identity a -> b -> b Source #
Unbox a => MVector MVector ( Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Identity a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Identity a) -> MVector s ( Identity a) Source # basicOverlaps :: MVector s ( Identity a) -> MVector s ( Identity a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Identity a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Identity a -> m ( MVector ( PrimState m) ( Identity a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> Int -> m ( Identity a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> Int -> Identity a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> Identity a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> MVector ( PrimState m) ( Identity a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> MVector ( PrimState m) ( Identity a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Identity a) -> Int -> m ( MVector ( PrimState m) ( Identity a)) Source #
Bounded a => Bounded ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a Source # maxBound :: Identity a Source #
Enum a => Enum ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a Source # pred :: Identity a -> Identity a Source # toEnum :: Int -> Identity a Source # fromEnum :: Identity a -> Int Source # enumFrom :: Identity a -> [ Identity a] Source # enumFromThen :: Identity a -> Identity a -> [ Identity a] Source # enumFromTo :: Identity a -> Identity a -> [ Identity a] Source # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [ Identity a] Source #
Eq a => Eq ( Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool Source # (/=) :: Identity a -> Identity a -> Bool Source #
Floating a => Floating ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a Source # exp :: Identity a -> Identity a Source # log :: Identity a -> Identity a Source # sqrt :: Identity a -> Identity a Source # (**) :: Identity a -> Identity a -> Identity a Source # logBase :: Identity a -> Identity a -> Identity a Source # sin :: Identity a -> Identity a Source # cos :: Identity a -> Identity a Source # tan :: Identity a -> Identity a Source # asin :: Identity a -> Identity a Source # acos :: Identity a -> Identity a Source # atan :: Identity a -> Identity a Source # sinh :: Identity a -> Identity a Source # cosh :: Identity a -> Identity a Source # tanh :: Identity a -> Identity a Source # asinh :: Identity a -> Identity a Source # acosh :: Identity a -> Identity a Source # atanh :: Identity a -> Identity a Source # log1p :: Identity a -> Identity a Source # expm1 :: Identity a -> Identity a Source # log1pexp :: Identity a -> Identity a Source # log1mexp :: Identity a -> Identity a Source #
Fractional a => Fractional ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a Source # recip :: Identity a -> Identity a Source # fromRational :: Rational -> Identity a Source #
Integral a => Integral ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a Source # rem :: Identity a -> Identity a -> Identity a Source # div :: Identity a -> Identity a -> Identity a Source # mod :: Identity a -> Identity a -> Identity a Source # quotRem :: Identity a -> Identity a -> ( Identity a, Identity a) Source # divMod :: Identity a -> Identity a -> ( Identity a, Identity a) Source # toInteger :: Identity a -> Integer Source #
Num a => Num ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a Source # (-) :: Identity a -> Identity a -> Identity a Source # (*) :: Identity a -> Identity a -> Identity a Source # negate :: Identity a -> Identity a Source # abs :: Identity a -> Identity a Source # signum :: Identity a -> Identity a Source # fromInteger :: Integer -> Identity a Source #
Ord a => Ord ( Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering Source # (<) :: Identity a -> Identity a -> Bool Source # (<=) :: Identity a -> Identity a -> Bool Source # (>) :: Identity a -> Identity a -> Bool Source # (>=) :: Identity a -> Identity a -> Bool Source # max :: Identity a -> Identity a -> Identity a Source # min :: Identity a -> Identity a -> Identity a Source #
Read a => Read ( Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS ( Identity a) Source # readList :: ReadS [ Identity a] Source # readPrec :: ReadPrec ( Identity a) Source # readListPrec :: ReadPrec [ Identity a] Source #
Real a => Real ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational Source #
RealFloat a => RealFloat ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer Source # floatDigits :: Identity a -> Int Source # floatRange :: Identity a -> ( Int , Int ) Source # decodeFloat :: Identity a -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Identity a Source # exponent :: Identity a -> Int Source # significand :: Identity a -> Identity a Source # scaleFloat :: Int -> Identity a -> Identity a Source # isNaN :: Identity a -> Bool Source # isInfinite :: Identity a -> Bool Source # isDenormalized :: Identity a -> Bool Source # isNegativeZero :: Identity a -> Bool Source # isIEEE :: Identity a -> Bool Source # atan2 :: Identity a -> Identity a -> Identity a Source #
RealFrac a => RealFrac ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) Source # truncate :: Integral b => Identity a -> b Source # round :: Integral b => Identity a -> b Source # ceiling :: Integral b => Identity a -> b Source # floor :: Integral b => Identity a -> b Source #
Show a => Show ( Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS Source # show :: Identity a -> String Source # showList :: [ Identity a] -> ShowS Source #
Ix a => Ix ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods range :: ( Identity a, Identity a) -> [ Identity a] Source # index :: ( Identity a, Identity a) -> Identity a -> Int Source # unsafeIndex :: ( Identity a, Identity a) -> Identity a -> Int Source # inRange :: ( Identity a, Identity a) -> Identity a -> Bool Source # rangeSize :: ( Identity a, Identity a) -> Int Source # unsafeRangeSize :: ( Identity a, Identity a) -> Int Source #
IsString a => IsString ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a Source #
Generic ( Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Associated Types type Rep ( Identity a) :: Type -> Type Source # Methods from :: Identity a -> Rep ( Identity a) x Source # to :: Rep ( Identity a) x -> Identity a Source #
Semigroup a => Semigroup ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a Source # sconcat :: NonEmpty ( Identity a) -> Identity a Source # stimes :: Integral b => b -> Identity a -> Identity a Source #
Monoid a => Monoid ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a Source # mappend :: Identity a -> Identity a -> Identity a Source # mconcat :: [ Identity a] -> Identity a Source #
Hashable a => Hashable ( Identity a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int Source # hash :: Identity a -> Int Source #
Storable a => Storable ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int Source # alignment :: Identity a -> Int Source # peekElemOff :: Ptr ( Identity a) -> Int -> IO ( Identity a) Source # pokeElemOff :: Ptr ( Identity a) -> Int -> Identity a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Identity a) Source # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () Source # peek :: Ptr ( Identity a) -> IO ( Identity a) Source # poke :: Ptr ( Identity a) -> Identity a -> IO () Source #
Bits a => Bits ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a Source # (.\|.) :: Identity a -> Identity a -> Identity a Source # xor :: Identity a -> Identity a -> Identity a Source # complement :: Identity a -> Identity a Source # shift :: Identity a -> Int -> Identity a Source # rotate :: Identity a -> Int -> Identity a Source # zeroBits :: Identity a Source # bit :: Int -> Identity a Source # setBit :: Identity a -> Int -> Identity a Source # clearBit :: Identity a -> Int -> Identity a Source # complementBit :: Identity a -> Int -> Identity a Source # testBit :: Identity a -> Int -> Bool Source # bitSizeMaybe :: Identity a -> Maybe Int Source # bitSize :: Identity a -> Int Source # isSigned :: Identity a -> Bool Source # shiftL :: Identity a -> Int -> Identity a Source # unsafeShiftL :: Identity a -> Int -> Identity a Source # shiftR :: Identity a -> Int -> Identity a Source # unsafeShiftR :: Identity a -> Int -> Identity a Source # rotateL :: Identity a -> Int -> Identity a Source # rotateR :: Identity a -> Int -> Identity a Source # popCount :: Identity a -> Int Source #
FiniteBits a => FiniteBits ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int Source # countLeadingZeros :: Identity a -> Int Source # countTrailingZeros :: Identity a -> Int Source #
NFData a => NFData ( Identity a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Identity a -> () Source #
Prim a => Prim ( Identity a)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Identity a -> Int# Source # alignment# :: Identity a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Identity a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Identity a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Identity a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Identity a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Identity a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Identity a #) Source # writeOffAddr# :: Addr# -> Int# -> Identity a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Identity a -> State# s -> State# s Source #
Unbox a => Unbox ( Identity a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type Source # Methods from1 :: forall (a :: k). Identity a -> Rep1 Identity a Source # to1 :: forall (a :: k). Rep1 Identity a -> Identity a Source #
newtype MVector s ( Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Identity a) = MV_Identity ( MVector s a)
type Rep ( Identity a)
Instance details Defined in Data.Functor.Identity type Rep ( Identity a) = D1 (' MetaData "Identity" "Data.Functor.Identity" "base" ' True ) ( C1 (' MetaCons "Identity" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "runIdentity") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
newtype Vector ( Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Identity a) = V_Identity ( Vector a)
type Rep1 Identity
Instance details Defined in Data.Functor.Identity type Rep1 Identity = D1 (' MetaData "Identity" "Data.Functor.Identity" "base" ' True ) ( C1 (' MetaCons "Identity" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "runIdentity") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 ))

withFile :: FilePath -> IOMode -> ( Handle -> IO r) -> IO r Source #

withFile name mode act opens a file using openFile and passes the resulting handle to the computation act . The handle will be closed on exit from withFile , whether by normal termination or by raising an exception. If closing the handle raises an exception, then this exception will be raised by withFile rather than any exception raised by act .

openFile :: FilePath -> IOMode -> IO Handle Source #

Computation openFile file mode allocates and returns a new, open handle to manage the file file . It manages input if mode is ReadMode , output if mode is WriteMode or AppendMode , and both input and output if mode is ReadWriteMode .

If the file does not exist and it is opened for output, it should be created as a new file. If mode is WriteMode and the file already exists, then it should be truncated to zero length. Some operating systems delete empty files, so there is no guarantee that the file will exist following an openFile with mode WriteMode unless it is subsequently written to successfully. The handle is positioned at the end of the file if mode is AppendMode , and otherwise at the beginning (in which case its internal position is 0). The initial buffer mode is implementation-dependent.

This operation may fail with:

isAlreadyInUseError if the file is already open and cannot be reopened;
isDoesNotExistError if the file does not exist or (on POSIX systems) is a FIFO without a reader and WriteMode was requested; or
isPermissionError if the user does not have permission to open the file.

Note: if you will be working with files containing binary data, you'll want to be using openBinaryFile .

stderr :: Handle Source #

A handle managing output to the Haskell program's standard error channel.

stdin :: Handle Source #

A handle managing input from the Haskell program's standard input channel.

threadDelay :: Int -> IO () Source #

Suspends the current thread for a given number of microseconds (GHC only).

There is no guarantee that the thread will be rescheduled promptly when the delay has expired, but the thread will never continue to run earlier than specified.

mkWeakMVar :: MVar a -> IO () -> IO ( Weak ( MVar a)) Source #

Make a Weak pointer to an MVar , using the second argument as a finalizer to run when MVar is garbage-collected

Since: base-4.6.0.0

addMVarFinalizer :: MVar a -> IO () -> IO () Source #

modifyMVarMasked :: MVar a -> (a -> IO (a, b)) -> IO b Source #

Like modifyMVar , but the IO action in the second argument is executed with asynchronous exceptions masked.

Since: base-4.6.0.0

modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO () Source #

Like modifyMVar_ , but the IO action in the second argument is executed with asynchronous exceptions masked.

Since: base-4.6.0.0

modifyMVar :: MVar a -> (a -> IO (a, b)) -> IO b Source #

A slight variation on modifyMVar_ that allows a value to be returned ( b ) in addition to the modified value of the MVar .

modifyMVar_ :: MVar a -> (a -> IO a) -> IO () Source #

An exception-safe wrapper for modifying the contents of an MVar . Like withMVar , modifyMVar will replace the original contents of the MVar if an exception is raised during the operation. This function is only atomic if there are no other producers for this MVar .

withMVarMasked :: MVar a -> (a -> IO b) -> IO b Source #

Like withMVar , but the IO action in the second argument is executed with asynchronous exceptions masked.

Since: base-4.7.0.0

withMVar :: MVar a -> (a -> IO b) -> IO b Source #

withMVar is an exception-safe wrapper for operating on the contents of an MVar . This operation is exception-safe: it will replace the original contents of the MVar if an exception is raised (see Control.Exception ). However, it is only atomic if there are no other producers for this MVar .

swapMVar :: MVar a -> a -> IO a Source #

Take a value from an MVar , put a new value into the MVar and return the value taken. This function is atomic only if there are no other producers for this MVar .

withFrozenCallStack :: HasCallStack => ( HasCallStack => a) -> a Source #

Perform some computation without adding new entries to the CallStack .

Since: base-4.9.0.0

callStack :: HasCallStack => CallStack Source #

Return the current CallStack .

Does *not* include the call-site of callStack .

Since: base-4.9.0.0

allowInterrupt :: IO () Source #

When invoked inside mask , this function allows a masked asynchronous exception to be raised, if one exists. It is equivalent to performing an interruptible operation (see #interruptible), but does not involve any actual blocking.

When called outside mask , or inside uninterruptibleMask , this function has no effect.

Since: base-4.4.0.0

catches :: IO a -> [ Handler a] -> IO a Source #

Sometimes you want to catch two different sorts of exception. You could do something like

f = expr `catch` \ (ex :: ArithException) -> handleArith ex
         `catch` \ (ex :: IOException)    -> handleIO    ex

However, there are a couple of problems with this approach. The first is that having two exception handlers is inefficient. However, the more serious issue is that the second exception handler will catch exceptions in the first, e.g. in the example above, if handleArith throws an IOException then the second exception handler will catch it.

Instead, we provide a function catches , which would be used thus:

f = expr `catches` [Handler (\ (ex :: ArithException) -> handleArith ex),
                    Handler (\ (ex :: IOException)    -> handleIO    ex)]

data Handler a Source #

You need this when using catches .

Constructors

Exception e => Handler (e -> IO a)

Instances

Instances details

Functor Handler	Since: base-4.6.0.0
Instance details Defined in Control.Exception Methods fmap :: (a -> b) -> Handler a -> Handler b Source # (<$) :: a -> Handler b -> Handler a Source #

fixST :: (a -> ST s a) -> ST s a Source #

Allow the result of an ST computation to be used (lazily) inside the computation.

Note that if f is strict, fixST f = _|_ .

bracketOnError Source #

Arguments

:: IO a	computation to run first ("acquire resource")
-> (a -> IO b)	computation to run last ("release resource")
-> (a -> IO c)	computation to run in-between
-> IO c

Like bracket , but only performs the final action if there was an exception raised by the in-between computation.

bracket_ :: IO a -> IO b -> IO c -> IO c Source #

A variant of bracket where the return value from the first computation is not required.

finally Source #

Arguments

:: IO a	computation to run first
-> IO b	computation to run afterward (even if an exception was raised)
-> IO a

A specialised variant of bracket with just a computation to run afterward.

bracket Source #

Arguments

:: IO a	computation to run first ("acquire resource")
-> (a -> IO b)	computation to run last ("release resource")
-> (a -> IO c)	computation to run in-between
-> IO c

When you want to acquire a resource, do some work with it, and then release the resource, it is a good idea to use bracket , because bracket will install the necessary exception handler to release the resource in the event that an exception is raised during the computation. If an exception is raised, then bracket will re-raise the exception (after performing the release).

A common example is opening a file:

bracket
  (openFile "filename" ReadMode)
  (hClose)
  (\fileHandle -> do { ... })

The arguments to bracket are in this order so that we can partially apply it, e.g.:

withFile name mode = bracket (openFile name mode) hClose

onException :: IO a -> IO b -> IO a Source #

Like finally , but only performs the final action if there was an exception raised by the computation.

tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO ( Either b a) Source #

A variant of try that takes an exception predicate to select which exceptions are caught (c.f. catchJust ). If the exception does not match the predicate, it is re-thrown.

try :: Exception e => IO a -> IO ( Either e a) Source #

Similar to catch , but returns an Either result which is ( Right a) if no exception of type e was raised, or ( Left ex) if an exception of type e was raised and its value is ex . If any other type of exception is raised than it will be propogated up to the next enclosing exception handler.

 try a = catch (Right `liftM` a) (return . Left)

mapException :: ( Exception e1, Exception e2) => (e1 -> e2) -> a -> a Source #

This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".

handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a Source #

A version of catchJust with the arguments swapped around (see handle ).

handle :: Exception e => (e -> IO a) -> IO a -> IO a Source #

A version of catch with the arguments swapped around; useful in situations where the code for the handler is shorter. For example:

  do handle (\NonTermination -> exitWith (ExitFailure 1)) $
     ...

catchJust Source #

Arguments

:: Exception e
=> (e -> Maybe b)	Predicate to select exceptions
-> IO a	Computation to run
-> (b -> IO a)	Handler
-> IO a

The function catchJust is like catch , but it takes an extra argument which is an exception predicate , a function which selects which type of exceptions we're interested in.

catchJust (\e -> if isDoesNotExistErrorType (ioeGetErrorType e) then Just () else Nothing)
          (readFile f)
          (\_ -> do hPutStrLn stderr ("No such file: " ++ show f)
                    return "")

Any other exceptions which are not matched by the predicate are re-raised, and may be caught by an enclosing catch , catchJust , etc.

newtype PatternMatchFail Source #

A pattern match failed. The String gives information about the source location of the pattern.

Constructors

PatternMatchFail String

Instances

Instances details

Show PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> PatternMatchFail -> ShowS Source # show :: PatternMatchFail -> String Source # showList :: [ PatternMatchFail ] -> ShowS Source #
Exception PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException Source # fromException :: SomeException -> Maybe PatternMatchFail Source # displayException :: PatternMatchFail -> String Source #

newtype RecSelError Source #

A record selector was applied to a constructor without the appropriate field. This can only happen with a datatype with multiple constructors, where some fields are in one constructor but not another. The String gives information about the source location of the record selector.

Constructors

RecSelError String

Instances

Instances details

Show RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecSelError -> ShowS Source # show :: RecSelError -> String Source # showList :: [ RecSelError ] -> ShowS Source #
Exception RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException Source # fromException :: SomeException -> Maybe RecSelError Source # displayException :: RecSelError -> String Source #

newtype RecConError Source #

An uninitialised record field was used. The String gives information about the source location where the record was constructed.

Constructors

RecConError String

Instances

Instances details

Show RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecConError -> ShowS Source # show :: RecConError -> String Source # showList :: [ RecConError ] -> ShowS Source #
Exception RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException Source # fromException :: SomeException -> Maybe RecConError Source # displayException :: RecConError -> String Source #

newtype RecUpdError Source #

A record update was performed on a constructor without the appropriate field. This can only happen with a datatype with multiple constructors, where some fields are in one constructor but not another. The String gives information about the source location of the record update.

Constructors

RecUpdError String

Instances

Instances details

Show RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecUpdError -> ShowS Source # show :: RecUpdError -> String Source # showList :: [ RecUpdError ] -> ShowS Source #
Exception RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException Source # fromException :: SomeException -> Maybe RecUpdError Source # displayException :: RecUpdError -> String Source #

newtype NoMethodError Source #

A class method without a definition (neither a default definition, nor a definition in the appropriate instance) was called. The String gives information about which method it was.

Constructors

NoMethodError String

Instances

Instances details

Show NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NoMethodError -> ShowS Source # show :: NoMethodError -> String Source # showList :: [ NoMethodError ] -> ShowS Source #
Exception NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException Source # fromException :: SomeException -> Maybe NoMethodError Source # displayException :: NoMethodError -> String Source #

newtype TypeError Source #

An expression that didn't typecheck during compile time was called. This is only possible with -fdefer-type-errors. The String gives details about the failed type check.

Since: base-4.9.0.0

Constructors

TypeError String

Instances

Instances details

Show TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> TypeError -> ShowS Source # show :: TypeError -> String Source # showList :: [ TypeError ] -> ShowS Source #
Exception TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException Source # fromException :: SomeException -> Maybe TypeError Source # displayException :: TypeError -> String Source #

data NonTermination Source #

Thrown when the runtime system detects that the computation is guaranteed not to terminate. Note that there is no guarantee that the runtime system will notice whether any given computation is guaranteed to terminate or not.

Constructors

NonTermination

Instances

Instances details

Show NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NonTermination -> ShowS Source # show :: NonTermination -> String Source # showList :: [ NonTermination ] -> ShowS Source #
Exception NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException Source # fromException :: SomeException -> Maybe NonTermination Source # displayException :: NonTermination -> String Source #

data NestedAtomically Source #

Thrown when the program attempts to call atomically , from the stm package, inside another call to atomically .

Constructors

NestedAtomically

Instances

Instances details

Show NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NestedAtomically -> ShowS Source # show :: NestedAtomically -> String Source # showList :: [ NestedAtomically ] -> ShowS Source #
Exception NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException Source # fromException :: SomeException -> Maybe NestedAtomically Source # displayException :: NestedAtomically -> String Source #

catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a Source #

Exception handling within STM actions.

catchSTM m f catches any exception thrown by m using throwSTM , using the function f to handle the exception. If an exception is thrown, any changes made by m are rolled back, but changes prior to m persist.

throwSTM :: Exception e => e -> STM a Source #

A variant of throw that can only be used within the STM monad.

Throwing an exception in STM aborts the transaction and propagates the exception. If the exception is caught via catchSTM , only the changes enclosed by the catch are rolled back; changes made outside of catchSTM persist.

If the exception is not caught inside of the STM , it is re-thrown by atomically , and the entire STM is rolled back.

Although throwSTM has a type that is an instance of the type of throw , the two functions are subtly different:

throw e    `seq` x  ===> throw e
throwSTM e `seq` x  ===> x

The first example will cause the exception e to be raised, whereas the second one won't. In fact, throwSTM will only cause an exception to be raised when it is used within the STM monad. The throwSTM variant should be used in preference to throw to raise an exception within the STM monad because it guarantees ordering with respect to other STM operations, whereas throw does not.

orElse :: STM a -> STM a -> STM a Source #

Compose two alternative STM actions (GHC only).

If the first action completes without retrying then it forms the result of the orElse . Otherwise, if the first action retries, then the second action is tried in its place. If both actions retry then the orElse as a whole retries.

retry :: STM a Source #

Retry execution of the current memory transaction because it has seen values in TVar s which mean that it should not continue (e.g. the TVar s represent a shared buffer that is now empty). The implementation may block the thread until one of the TVar s that it has read from has been updated. (GHC only)

atomically :: STM a -> IO a Source #

Perform a series of STM actions atomically.

Using atomically inside an unsafePerformIO or unsafeInterleaveIO subverts some of guarantees that STM provides. It makes it possible to run a transaction inside of another transaction, depending on when the thunk is evaluated. If a nested transaction is attempted, an exception is thrown by the runtime. It is possible to safely use atomically inside unsafePerformIO or unsafeInterleaveIO , but the typechecker does not rule out programs that may attempt nested transactions, meaning that the programmer must take special care to prevent these.

However, there are functions for creating transactional variables that can always be safely called in unsafePerformIO . See: newTVarIO , newTChanIO , newBroadcastTChanIO , newTQueueIO , newTBQueueIO , and newTMVarIO .

Using unsafePerformIO inside of atomically is also dangerous but for different reasons. See unsafeIOToSTM for more on this.

mkWeakThreadId :: ThreadId -> IO ( Weak ThreadId ) Source #

Make a weak pointer to a ThreadId . It can be important to do this if you want to hold a reference to a ThreadId while still allowing the thread to receive the BlockedIndefinitely family of exceptions (e.g. BlockedIndefinitelyOnMVar ). Holding a normal ThreadId reference will prevent the delivery of BlockedIndefinitely exceptions because the reference could be used as the target of throwTo at any time, which would unblock the thread.

Holding a Weak ThreadId , on the other hand, will not prevent the thread from receiving BlockedIndefinitely exceptions. It is still possible to throw an exception to a Weak ThreadId , but the caller must use deRefWeak first to determine whether the thread still exists.

Since: base-4.6.0.0

threadCapability :: ThreadId -> IO ( Int , Bool ) Source #

Returns the number of the capability on which the thread is currently running, and a boolean indicating whether the thread is locked to that capability or not. A thread is locked to a capability if it was created with forkOn .

Since: base-4.4.0.0

yield :: IO () Source #

The yield action allows (forces, in a co-operative multitasking implementation) a context-switch to any other currently runnable threads (if any), and is occasionally useful when implementing concurrency abstractions.

myThreadId :: IO ThreadId Source #

Returns the ThreadId of the calling thread (GHC only).

killThread :: ThreadId -> IO () Source #

killThread raises the ThreadKilled exception in the given thread (GHC only).

killThread tid = throwTo tid ThreadKilled

setNumCapabilities :: Int -> IO () Source #

Set the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. The number passed to forkOn is interpreted modulo this value. The initial value is given by the +RTS -N runtime flag.

This is also the number of threads that will participate in parallel garbage collection. It is strongly recommended that the number of capabilities is not set larger than the number of physical processor cores, and it may often be beneficial to leave one or more cores free to avoid contention with other processes in the machine.

Since: base-4.5.0.0

getNumCapabilities :: IO Int Source #

Returns the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. To change this value, use setNumCapabilities .

Since: base-4.4.0.0

data STM a Source #

A monad supporting atomic memory transactions.

Instances

Instances details

Monad STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b Source # (>>) :: STM a -> STM b -> STM b Source # return :: a -> STM a Source #
Functor STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b Source # (<$) :: a -> STM b -> STM a Source #
Applicative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods pure :: a -> STM a Source # (<>) :: STM (a -> b) -> STM a -> STM b Source # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c Source # (>) :: STM a -> STM b -> STM b Source # (<*) :: STM a -> STM b -> STM a Source #
Alternative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods empty :: STM a Source # (<\|>) :: STM a -> STM a -> STM a Source # some :: STM a -> STM [a] Source # many :: STM a -> STM [a] Source #
MonadPlus STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods mzero :: STM a Source # mplus :: STM a -> STM a -> STM a Source #
RandomGen g => StatefulGen ( TGenM g) STM	Since: random-1.2.1
Instance details Defined in System.Random.Stateful Methods uniformWord32R :: Word32 -> TGenM g -> STM Word32 Source # uniformWord64R :: Word64 -> TGenM g -> STM Word64 Source # uniformWord8 :: TGenM g -> STM Word8 Source # uniformWord16 :: TGenM g -> STM Word16 Source # uniformWord32 :: TGenM g -> STM Word32 Source # uniformWord64 :: TGenM g -> STM Word64 Source # uniformShortByteString :: Int -> TGenM g -> STM ShortByteString Source #
RandomGen g => FrozenGen ( TGen g) STM	Since: random-1.2.1
Instance details Defined in System.Random.Stateful Associated Types type MutableGen ( TGen g) STM = (g :: Type ) Source # Methods freezeGen :: MutableGen ( TGen g) STM -> STM ( TGen g) Source # thawGen :: TGen g -> STM ( MutableGen ( TGen g) STM ) Source #
RandomGen r => RandomGenM ( TGenM r) r STM
Instance details Defined in System.Random.Stateful Methods applyRandomGenM :: (r -> (a, r)) -> TGenM r -> STM a Source #
type MutableGen ( TGen g) STM
Instance details Defined in System.Random.Stateful type MutableGen ( TGen g) STM = TGenM g

ioError :: IOError -> IO a Source #

Raise an IOError in the IO monad.

asyncExceptionFromException :: Exception e => SomeException -> Maybe e Source #

Since: base-4.7.0.0

asyncExceptionToException :: Exception e => e -> SomeException Source #

Since: base-4.7.0.0

data BlockedIndefinitelyOnMVar Source #

The thread is blocked on an MVar , but there are no other references to the MVar so it can't ever continue.

Constructors

BlockedIndefinitelyOnMVar

Instances

Instances details

Show BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS Source # show :: BlockedIndefinitelyOnMVar -> String Source # showList :: [ BlockedIndefinitelyOnMVar ] -> ShowS Source #
Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException Source # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar Source # displayException :: BlockedIndefinitelyOnMVar -> String Source #

data BlockedIndefinitelyOnSTM Source #

The thread is waiting to retry an STM transaction, but there are no other references to any TVar s involved, so it can't ever continue.

Constructors

BlockedIndefinitelyOnSTM

Instances

Instances details

Show BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS Source # show :: BlockedIndefinitelyOnSTM -> String Source # showList :: [ BlockedIndefinitelyOnSTM ] -> ShowS Source #
Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException Source # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM Source # displayException :: BlockedIndefinitelyOnSTM -> String Source #

data Deadlock Source #

There are no runnable threads, so the program is deadlocked. The Deadlock exception is raised in the main thread only.

Constructors

Deadlock

Instances

Instances details

Show Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> Deadlock -> ShowS Source # show :: Deadlock -> String Source # showList :: [ Deadlock ] -> ShowS Source #
Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException Source # fromException :: SomeException -> Maybe Deadlock Source # displayException :: Deadlock -> String Source #

data AllocationLimitExceeded Source #

This thread has exceeded its allocation limit. See setAllocationCounter and enableAllocationLimit .

Since: base-4.8.0.0

Constructors

AllocationLimitExceeded

Instances

Instances details

Show AllocationLimitExceeded	Since: base-4.7.1.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS Source # show :: AllocationLimitExceeded -> String Source # showList :: [ AllocationLimitExceeded ] -> ShowS Source #
Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException Source # fromException :: SomeException -> Maybe AllocationLimitExceeded Source # displayException :: AllocationLimitExceeded -> String Source #

newtype CompactionFailed Source #

Compaction found an object that cannot be compacted. Functions cannot be compacted, nor can mutable objects or pinned objects. See compact .

Since: base-4.10.0.0

Constructors

CompactionFailed String

Instances

Instances details

Show CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> CompactionFailed -> ShowS Source # show :: CompactionFailed -> String Source # showList :: [ CompactionFailed ] -> ShowS Source #
Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException Source # fromException :: SomeException -> Maybe CompactionFailed Source # displayException :: CompactionFailed -> String Source #

newtype AssertionFailed Source #

assert was applied to False .

Constructors

AssertionFailed String

Instances

Instances details

Show AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AssertionFailed -> ShowS Source # show :: AssertionFailed -> String Source # showList :: [ AssertionFailed ] -> ShowS Source #
Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException Source # fromException :: SomeException -> Maybe AssertionFailed Source # displayException :: AssertionFailed -> String Source #

data SomeAsyncException Source #

Superclass for asynchronous exceptions.

Since: base-4.7.0.0

Constructors

Exception e => SomeAsyncException e

Instances

Instances details

Show SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> SomeAsyncException -> ShowS Source # show :: SomeAsyncException -> String Source # showList :: [ SomeAsyncException ] -> ShowS Source #
Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException Source # fromException :: SomeException -> Maybe SomeAsyncException Source # displayException :: SomeAsyncException -> String Source #

data AsyncException Source #

Asynchronous exceptions.

Constructors

StackOverflow	The current thread's stack exceeded its limit. Since an exception has been raised, the thread's stack will certainly be below its limit again, but the programmer should take remedial action immediately.
HeapOverflow	The program's heap is reaching its limit, and the program should take action to reduce the amount of live data it has. Notes: It is undefined which thread receives this exception. GHC currently throws this to the same thread that receives `UserInterrupt` , but this may change in the future. The GHC RTS currently can only recover from heap overflow if it detects that an explicit memory limit (set via RTS flags). has been exceeded. Currently, failure to allocate memory from the operating system results in immediate termination of the program.
ThreadKilled	This exception is raised by another thread calling `killThread` , or by the system if it needs to terminate the thread for some reason.
UserInterrupt	This exception is raised by default in the main thread of the program when the user requests to terminate the program via the usual mechanism(s) (e.g. Control-C in the console).

Instances

Instances details

Eq AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool Source # (/=) :: AsyncException -> AsyncException -> Bool Source #
Ord AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering Source # (<) :: AsyncException -> AsyncException -> Bool Source # (<=) :: AsyncException -> AsyncException -> Bool Source # (>) :: AsyncException -> AsyncException -> Bool Source # (>=) :: AsyncException -> AsyncException -> Bool Source # max :: AsyncException -> AsyncException -> AsyncException Source # min :: AsyncException -> AsyncException -> AsyncException Source #
Show AsyncException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AsyncException -> ShowS Source # show :: AsyncException -> String Source # showList :: [ AsyncException ] -> ShowS Source #
Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException Source # fromException :: SomeException -> Maybe AsyncException Source # displayException :: AsyncException -> String Source #

data ArrayException Source #

Exceptions generated by array operations

Constructors

IndexOutOfBounds String	An attempt was made to index an array outside its declared bounds.
UndefinedElement String	An attempt was made to evaluate an element of an array that had not been initialized.

Instances

Instances details

Eq ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool Source # (/=) :: ArrayException -> ArrayException -> Bool Source #
Ord ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering Source # (<) :: ArrayException -> ArrayException -> Bool Source # (<=) :: ArrayException -> ArrayException -> Bool Source # (>) :: ArrayException -> ArrayException -> Bool Source # (>=) :: ArrayException -> ArrayException -> Bool Source # max :: ArrayException -> ArrayException -> ArrayException Source # min :: ArrayException -> ArrayException -> ArrayException Source #
Show ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ArrayException -> ShowS Source # show :: ArrayException -> String Source # showList :: [ ArrayException ] -> ShowS Source #
Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException Source # fromException :: SomeException -> Maybe ArrayException Source # displayException :: ArrayException -> String Source #

data ExitCode Source #

Defines the exit codes that a program can return.

Constructors

ExitSuccess	indicates successful termination;
ExitFailure Int	indicates program failure with an exit code. The exact interpretation of the code is operating-system dependent. In particular, some values may be prohibited (e.g. 0 on a POSIX-compliant system).

Instances

Instances details

Eq ExitCode
Instance details Defined in GHC.IO.Exception Methods (==) :: ExitCode -> ExitCode -> Bool Source # (/=) :: ExitCode -> ExitCode -> Bool Source #
Ord ExitCode
Instance details Defined in GHC.IO.Exception Methods compare :: ExitCode -> ExitCode -> Ordering Source # (<) :: ExitCode -> ExitCode -> Bool Source # (<=) :: ExitCode -> ExitCode -> Bool Source # (>) :: ExitCode -> ExitCode -> Bool Source # (>=) :: ExitCode -> ExitCode -> Bool Source # max :: ExitCode -> ExitCode -> ExitCode Source # min :: ExitCode -> ExitCode -> ExitCode Source #
Read ExitCode
Instance details Defined in GHC.IO.Exception Methods readsPrec :: Int -> ReadS ExitCode Source # readList :: ReadS [ ExitCode ] Source # readPrec :: ReadPrec ExitCode Source # readListPrec :: ReadPrec [ ExitCode ] Source #
Show ExitCode
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ExitCode -> ShowS Source # show :: ExitCode -> String Source # showList :: [ ExitCode ] -> ShowS Source #
Generic ExitCode
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type Source # Methods from :: ExitCode -> Rep ExitCode x Source # to :: Rep ExitCode x -> ExitCode Source #
Exception ExitCode	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException Source # fromException :: SomeException -> Maybe ExitCode Source # displayException :: ExitCode -> String Source #
NFData ExitCode	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: ExitCode -> () Source #
type Rep ExitCode
Instance details Defined in GHC.IO.Exception type Rep ExitCode = D1 (' MetaData "ExitCode" "GHC.IO.Exception" "base" ' False ) ( C1 (' MetaCons "ExitSuccess" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "ExitFailure" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int )))

stdout :: Handle Source #

A handle managing output to the Haskell program's standard output channel.

evaluate :: a -> IO a Source #

Evaluate the argument to weak head normal form.

evaluate is typically used to uncover any exceptions that a lazy value may contain, and possibly handle them.

evaluate only evaluates to weak head normal form . If deeper evaluation is needed, the force function from Control.DeepSeq may be handy:

evaluate $ force x

There is a subtle difference between evaluate x and return $! x , analogous to the difference between throwIO and throw . If the lazy value x throws an exception, return $! x will fail to return an IO action and will throw an exception instead. evaluate x , on the other hand, always produces an IO action; that action will throw an exception upon execution iff x throws an exception upon evaluation .

The practical implication of this difference is that due to the imprecise exceptions semantics,

(return $! error "foo") >> error "bar"

may throw either "foo" or "bar" , depending on the optimizations performed by the compiler. On the other hand,

evaluate (error "foo") >> error "bar"

is guaranteed to throw "foo" .

The rule of thumb is to use evaluate to force or handle exceptions in lazy values. If, on the other hand, you are forcing a lazy value for efficiency reasons only and do not care about exceptions, you may use return $! x .

uninterruptibleMask :: (( forall a. IO a -> IO a) -> IO b) -> IO b Source #

Like mask , but the masked computation is not interruptible (see Control.Exception ). THIS SHOULD BE USED WITH GREAT CARE, because if a thread executing in uninterruptibleMask blocks for any reason, then the thread (and possibly the program, if this is the main thread) will be unresponsive and unkillable. This function should only be necessary if you need to mask exceptions around an interruptible operation, and you can guarantee that the interruptible operation will only block for a short period of time.

uninterruptibleMask_ :: IO a -> IO a Source #

Like uninterruptibleMask , but does not pass a restore action to the argument.

mask :: (( forall a. IO a -> IO a) -> IO b) -> IO b Source #

Executes an IO computation with asynchronous exceptions masked . That is, any thread which attempts to raise an exception in the current thread with throwTo will be blocked until asynchronous exceptions are unmasked again.

The argument passed to mask is a function that takes as its argument another function, which can be used to restore the prevailing masking state within the context of the masked computation. For example, a common way to use mask is to protect the acquisition of a resource:

mask $ \restore -> do
    x <- acquire
    restore (do_something_with x) `onException` release
    release

This code guarantees that acquire is paired with release , by masking asynchronous exceptions for the critical parts. (Rather than write this code yourself, it would be better to use bracket which abstracts the general pattern).

Note that the restore action passed to the argument to mask does not necessarily unmask asynchronous exceptions, it just restores the masking state to that of the enclosing context. Thus if asynchronous exceptions are already masked, mask cannot be used to unmask exceptions again. This is so that if you call a library function with exceptions masked, you can be sure that the library call will not be able to unmask exceptions again. If you are writing library code and need to use asynchronous exceptions, the only way is to create a new thread; see forkIOWithUnmask .

Asynchronous exceptions may still be received while in the masked state if the masked thread blocks in certain ways; see Control.Exception .

Threads created by forkIO inherit the MaskingState from the parent; that is, to start a thread in the MaskedInterruptible state, use mask_ $ forkIO ... . This is particularly useful if you need to establish an exception handler in the forked thread before any asynchronous exceptions are received. To create a new thread in an unmasked state use forkIOWithUnmask .

mask_ :: IO a -> IO a Source #

Like mask , but does not pass a restore action to the argument.

getMaskingState :: IO MaskingState Source #

Returns the MaskingState for the current thread.

interruptible :: IO a -> IO a Source #

Allow asynchronous exceptions to be raised even inside mask , making the operation interruptible (see the discussion of "Interruptible operations" in Exception ).

When called outside mask , or inside uninterruptibleMask , this function has no effect.

Since: base-4.9.0.0

catch Source #

Arguments

:: Exception e
=> IO a	The computation to run
-> (e -> IO a)	Handler to invoke if an exception is raised
-> IO a

This is the simplest of the exception-catching functions. It takes a single argument, runs it, and if an exception is raised the "handler" is executed, with the value of the exception passed as an argument. Otherwise, the result is returned as normal. For example:

  catch (readFile f)
        (\e -> do let err = show (e :: IOException)
                  hPutStr stderr ("Warning: Couldn't open " ++ f ++ ": " ++ err)
                  return "")

Note that we have to give a type signature to e , or the program will not typecheck as the type is ambiguous. While it is possible to catch exceptions of any type, see the section "Catching all exceptions" (in Control.Exception ) for an explanation of the problems with doing so.

For catching exceptions in pure (non- IO ) expressions, see the function evaluate .

Note that due to Haskell's unspecified evaluation order, an expression may throw one of several possible exceptions: consider the expression (error "urk") + (1 `div` 0) . Does the expression throw ErrorCall "urk" , or DivideByZero ?

The answer is "it might throw either"; the choice is non-deterministic. If you are catching any type of exception then you might catch either. If you are calling catch with type IO Int -> (ArithException -> IO Int) -> IO Int then the handler may get run with DivideByZero as an argument, or an ErrorCall "urk" exception may be propogated further up. If you call it again, you might get a the opposite behaviour. This is ok, because catch is an IO computation.

type FilePath = String Source #

File and directory names are values of type String , whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.

data MaskingState Source #

Describes the behaviour of a thread when an asynchronous exception is received.

Constructors

Unmasked	asynchronous exceptions are unmasked (the normal state)
MaskedInterruptible	the state during `mask` : asynchronous exceptions are masked, but blocking operations may still be interrupted
MaskedUninterruptible	the state during `uninterruptibleMask` : asynchronous exceptions are masked, and blocking operations may not be interrupted

Instances

Instances details

Eq MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool Source # (/=) :: MaskingState -> MaskingState -> Bool Source #
Show MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods showsPrec :: Int -> MaskingState -> ShowS Source # show :: MaskingState -> String Source # showList :: [ MaskingState ] -> ShowS Source #
NFData MaskingState	Since: deepseq-1.4.4.0
Instance details Defined in Control.DeepSeq Methods rnf :: MaskingState -> () Source #

data IOException Source #

Exceptions that occur in the IO monad. An IOException records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.

Instances

Instances details

Eq IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOException -> IOException -> Bool Source # (/=) :: IOException -> IOException -> Bool Source #
Show IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOException -> ShowS Source # show :: IOException -> String Source # showList :: [ IOException ] -> ShowS Source #
Exception IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException Source # fromException :: SomeException -> Maybe IOException Source # displayException :: IOException -> String Source #
Error IOException
Instance details Defined in Control.Monad.Trans.Error Methods noMsg :: IOException Source # strMsg :: String -> IOException Source #
MonadError IOException IO
Instance details Defined in Control.Monad.Error.Class Methods throwError :: IOException -> IO a Source # catchError :: IO a -> ( IOException -> IO a) -> IO a Source #

prettyCallStack :: CallStack -> String Source #

Pretty print a CallStack .

Since: base-4.9.0.0

prettySrcLoc :: SrcLoc -> String Source #

Pretty print a SrcLoc .

Since: base-4.9.0.0

data ErrorCall Source #

This is thrown when the user calls error . The first String is the argument given to error , second String is the location.

Constructors

ErrorCallWithLocation String String

Bundled Patterns

pattern ErrorCall :: String -> ErrorCall

Instances

Instances details

Eq ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods (==) :: ErrorCall -> ErrorCall -> Bool Source # (/=) :: ErrorCall -> ErrorCall -> Bool Source #
Ord ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods compare :: ErrorCall -> ErrorCall -> Ordering Source # (<) :: ErrorCall -> ErrorCall -> Bool Source # (<=) :: ErrorCall -> ErrorCall -> Bool Source # (>) :: ErrorCall -> ErrorCall -> Bool Source # (>=) :: ErrorCall -> ErrorCall -> Bool Source # max :: ErrorCall -> ErrorCall -> ErrorCall Source # min :: ErrorCall -> ErrorCall -> ErrorCall Source #
Show ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods showsPrec :: Int -> ErrorCall -> ShowS Source # show :: ErrorCall -> String Source # showList :: [ ErrorCall ] -> ShowS Source #
Exception ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException Source # fromException :: SomeException -> Maybe ErrorCall Source # displayException :: ErrorCall -> String Source #

class ( Typeable e, Show e) => Exception e where Source #

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

data MyException = ThisException | ThatException
    deriving Show

instance Exception MyException

The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e

instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e

instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
    deriving Show

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

We can now catch a MismatchedParentheses exception as MismatchedParentheses , SomeFrontendException or SomeCompilerException , but not other types, e.g. IOException :

*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException Source #

fromException :: SomeException -> Maybe e Source #

displayException :: e -> String Source #

Render this exception value in a human-friendly manner.

Default implementation: show .

Since: base-4.8.0.0

Instances

Instances details

Exception AsyncCancelled
Instance details Defined in Control.Concurrent.Async Methods toException :: AsyncCancelled -> SomeException Source # fromException :: SomeException -> Maybe AsyncCancelled Source # displayException :: AsyncCancelled -> String Source #
Exception ExceptionInLinkedThread
Instance details Defined in Control.Concurrent.Async Methods toException :: ExceptionInLinkedThread -> SomeException Source # fromException :: SomeException -> Maybe ExceptionInLinkedThread Source # displayException :: ExceptionInLinkedThread -> String Source #
Exception Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods toException :: Void -> SomeException Source # fromException :: SomeException -> Maybe Void Source # displayException :: Void -> String Source #
Exception PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException Source # fromException :: SomeException -> Maybe PatternMatchFail Source # displayException :: PatternMatchFail -> String Source #
Exception RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException Source # fromException :: SomeException -> Maybe RecSelError Source # displayException :: RecSelError -> String Source #
Exception RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException Source # fromException :: SomeException -> Maybe RecConError Source # displayException :: RecConError -> String Source #
Exception RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException Source # fromException :: SomeException -> Maybe RecUpdError Source # displayException :: RecUpdError -> String Source #
Exception NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException Source # fromException :: SomeException -> Maybe NoMethodError Source # displayException :: NoMethodError -> String Source #
Exception TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException Source # fromException :: SomeException -> Maybe TypeError Source # displayException :: TypeError -> String Source #
Exception NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException Source # fromException :: SomeException -> Maybe NonTermination Source # displayException :: NonTermination -> String Source #
Exception NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException Source # fromException :: SomeException -> Maybe NestedAtomically Source # displayException :: NestedAtomically -> String Source #
Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException Source # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar Source # displayException :: BlockedIndefinitelyOnMVar -> String Source #
Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException Source # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM Source # displayException :: BlockedIndefinitelyOnSTM -> String Source #
Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException Source # fromException :: SomeException -> Maybe Deadlock Source # displayException :: Deadlock -> String Source #
Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException Source # fromException :: SomeException -> Maybe AllocationLimitExceeded Source # displayException :: AllocationLimitExceeded -> String Source #
Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException Source # fromException :: SomeException -> Maybe CompactionFailed Source # displayException :: CompactionFailed -> String Source #
Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException Source # fromException :: SomeException -> Maybe AssertionFailed Source # displayException :: AssertionFailed -> String Source #
Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException Source # fromException :: SomeException -> Maybe SomeAsyncException Source # displayException :: SomeAsyncException -> String Source #
Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException Source # fromException :: SomeException -> Maybe AsyncException Source # displayException :: AsyncException -> String Source #
Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException Source # fromException :: SomeException -> Maybe ArrayException Source # displayException :: ArrayException -> String Source #
Exception FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: FixIOException -> SomeException Source # fromException :: SomeException -> Maybe FixIOException Source # displayException :: FixIOException -> String Source #
Exception ExitCode	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException Source # fromException :: SomeException -> Maybe ExitCode Source # displayException :: ExitCode -> String Source #
Exception IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException Source # fromException :: SomeException -> Maybe IOException Source # displayException :: IOException -> String Source #
Exception ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException Source # fromException :: SomeException -> Maybe ErrorCall Source # displayException :: ErrorCall -> String Source #
Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException Source # fromException :: SomeException -> Maybe ArithException Source # displayException :: ArithException -> String Source #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException Source # fromException :: SomeException -> Maybe SomeException Source # displayException :: SomeException -> String Source #
Exception FatalError
Instance details Defined in Protolude.Panic Methods toException :: FatalError -> SomeException Source # fromException :: SomeException -> Maybe FatalError Source # displayException :: FatalError -> String Source #
Exception UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods toException :: UnicodeException -> SomeException Source # fromException :: SomeException -> Maybe UnicodeException Source # displayException :: UnicodeException -> String Source #

data ArithException Source #

Arithmetic exceptions.

Constructors

Overflow
Underflow
LossOfPrecision
DivideByZero
Denormal
RatioZeroDenominator	Since: base-4.6.0.0

Instances

Instances details

Eq ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool Source # (/=) :: ArithException -> ArithException -> Bool Source #
Ord ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering Source # (<) :: ArithException -> ArithException -> Bool Source # (<=) :: ArithException -> ArithException -> Bool Source # (>) :: ArithException -> ArithException -> Bool Source # (>=) :: ArithException -> ArithException -> Bool Source # max :: ArithException -> ArithException -> ArithException Source # min :: ArithException -> ArithException -> ArithException Source #
Show ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS Source # show :: ArithException -> String Source # showList :: [ ArithException ] -> ShowS Source #
Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException Source # fromException :: SomeException -> Maybe ArithException Source # displayException :: ArithException -> String Source #

gcast :: forall k (a :: k) (b :: k) c. ( Typeable a, Typeable b) => c a -> Maybe (c b) Source #

A flexible variation parameterised in a type constructor

eqT :: forall k (a :: k) (b :: k). ( Typeable a, Typeable b) => Maybe (a :~: b) Source #

Extract a witness of equality of two types

Since: base-4.7.0.0

cast :: ( Typeable a, Typeable b) => a -> Maybe b Source #

The type-safe cast operation

typeRep :: forall k proxy (a :: k). Typeable a => proxy a -> TypeRep Source #

Takes a value of type a and returns a concrete representation of that type.

Since: base-4.7.0.0

typeOf :: Typeable a => a -> TypeRep Source #

Observe a type representation for the type of a value.

type TypeRep = SomeTypeRep Source #

A quantified type representation.

newtype Const a (b :: k) Source #

The Const functor.

Constructors

Const
Fields getConst :: a

Instances

Instances details

Generic1 ( Const a :: k -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Associated Types type Rep1 ( Const a) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). Const a a0 -> Rep1 ( Const a) a0 Source # to1 :: forall (a0 :: k0). Rep1 ( Const a) a0 -> Const a a0 Source #
Unbox a => Vector Vector ( Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Const a b) -> m ( Vector ( Const a b)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Const a b) -> m ( Mutable Vector ( PrimState m) ( Const a b)) Source # basicLength :: Vector ( Const a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Const a b) -> Vector ( Const a b) Source # basicUnsafeIndexM :: Monad m => Vector ( Const a b) -> Int -> m ( Const a b) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Const a b) -> Vector ( Const a b) -> m () Source # elemseq :: Vector ( Const a b) -> Const a b -> b0 -> b0 Source #
Unbox a => MVector MVector ( Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Const a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Const a b) -> MVector s ( Const a b) Source # basicOverlaps :: MVector s ( Const a b) -> MVector s ( Const a b) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Const a b)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Const a b -> m ( MVector ( PrimState m) ( Const a b)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Int -> m ( Const a b) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Int -> Const a b -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Const a b -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> MVector ( PrimState m) ( Const a b) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> MVector ( PrimState m) ( Const a b) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Int -> m ( MVector ( PrimState m) ( Const a b)) Source #
Bifunctor ( Const :: Type -> Type -> Type )	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d Source # first :: (a -> b) -> Const a c -> Const b c Source # second :: (b -> c) -> Const a b -> Const a c Source #
Bifoldable ( Const :: Type -> Type -> Type )	Since: base-4.10.0.0
Instance details Defined in Data.Bifoldable Methods bifold :: Monoid m => Const m m -> m Source # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m Source # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c Source # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c Source #
NFData2 ( Const :: Type -> Type -> Type )	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Const a b -> () Source #
Hashable2 ( Const :: Type -> Type -> Type )
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: ( Int -> a -> Int ) -> ( Int -> b -> Int ) -> Int -> Const a b -> Int Source #
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 Source # (<$) :: a -> Const m b -> Const m a Source #
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 Source # (<>) :: Const m (a -> b) -> Const m a -> Const m b Source # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c Source # (>) :: Const m a -> Const m b -> Const m b Source # (<*) :: Const m a -> Const m b -> Const m a Source #
Foldable ( Const m :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 Source # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldr :: (a -> b -> b) -> b -> Const m a -> b Source # foldr' :: (a -> b -> b) -> b -> Const m a -> b Source # foldl :: (b -> a -> b) -> b -> Const m a -> b Source # foldl' :: (b -> a -> b) -> b -> Const m a -> b Source # foldr1 :: (a -> a -> a) -> Const m a -> a Source # foldl1 :: (a -> a -> a) -> Const m a -> a Source # toList :: Const m a -> [a] Source # null :: Const m a -> Bool Source # length :: Const m a -> Int Source # elem :: Eq a => a -> Const m a -> Bool Source # maximum :: Ord a => Const m a -> a Source # minimum :: Ord a => Const m a -> a Source # sum :: Num a => Const m a -> a Source # product :: Num a => Const m a -> a Source #
Traversable ( Const m :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f ( Const m b) Source # sequenceA :: Applicative f => Const m (f a) -> f ( Const m a) Source # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 ( Const m b) Source # sequence :: Monad m0 => Const m (m0 a) -> m0 ( Const m a) Source #
NFData a => NFData1 ( Const a :: Type -> Type )	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> Const a a0 -> () Source #
Hashable a => Hashable1 ( Const a :: Type -> Type )
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a0 -> Int ) -> Int -> Const a a0 -> Int Source #
Bounded a => Bounded ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b Source # maxBound :: Const a b Source #
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 Source # pred :: Const a b -> Const a b Source # toEnum :: Int -> Const a b Source # fromEnum :: Const a b -> Int Source # enumFrom :: Const a b -> [ Const a b] Source # enumFromThen :: Const a b -> Const a b -> [ Const a b] Source # enumFromTo :: Const a b -> Const a b -> [ Const a b] Source # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [ Const a b] Source #
Eq a => Eq ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool Source # (/=) :: Const a b -> Const a b -> Bool Source #
Floating a => Floating ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods pi :: Const a b Source # exp :: Const a b -> Const a b Source # log :: Const a b -> Const a b Source # sqrt :: Const a b -> Const a b Source # (**) :: Const a b -> Const a b -> Const a b Source # logBase :: Const a b -> Const a b -> Const a b Source # sin :: Const a b -> Const a b Source # cos :: Const a b -> Const a b Source # tan :: Const a b -> Const a b Source # asin :: Const a b -> Const a b Source # acos :: Const a b -> Const a b Source # atan :: Const a b -> Const a b Source # sinh :: Const a b -> Const a b Source # cosh :: Const a b -> Const a b Source # tanh :: Const a b -> Const a b Source # asinh :: Const a b -> Const a b Source # acosh :: Const a b -> Const a b Source # atanh :: Const a b -> Const a b Source # log1p :: Const a b -> Const a b Source # expm1 :: Const a b -> Const a b Source # log1pexp :: Const a b -> Const a b Source # log1mexp :: Const a b -> Const a b Source #
Fractional a => Fractional ( 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 Source # recip :: Const a b -> Const a b Source # fromRational :: Rational -> Const a b Source #
Integral a => Integral ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b Source # rem :: Const a b -> Const a b -> Const a b Source # div :: Const a b -> Const a b -> Const a b Source # mod :: Const a b -> Const a b -> Const a b Source # quotRem :: Const a b -> Const a b -> ( Const a b, Const a b) Source # divMod :: Const a b -> Const a b -> ( Const a b, Const a b) Source # toInteger :: Const a b -> Integer Source #
Num a => Num ( 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 Source # (-) :: Const a b -> Const a b -> Const a b Source # (*) :: Const a b -> Const a b -> Const a b Source # negate :: Const a b -> Const a b Source # abs :: Const a b -> Const a b Source # signum :: Const a b -> Const a b Source # fromInteger :: Integer -> Const a b Source #
Ord a => Ord ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering Source # (<) :: Const a b -> Const a b -> Bool Source # (<=) :: Const a b -> Const a b -> Bool Source # (>) :: Const a b -> Const a b -> Bool Source # (>=) :: Const a b -> Const a b -> Bool Source # max :: Const a b -> Const a b -> Const a b Source # min :: Const a b -> Const a b -> Const a b Source #
Read a => Read ( 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 readsPrec :: Int -> ReadS ( Const a b) Source # readList :: ReadS [ Const a b] Source # readPrec :: ReadPrec ( Const a b) Source # readListPrec :: ReadPrec [ Const a b] Source #
Real a => Real ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational Source #
RealFloat a => RealFloat ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer Source # floatDigits :: Const a b -> Int Source # floatRange :: Const a b -> ( Int , Int ) Source # decodeFloat :: Const a b -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Const a b Source # exponent :: Const a b -> Int Source # significand :: Const a b -> Const a b Source # scaleFloat :: Int -> Const a b -> Const a b Source # isNaN :: Const a b -> Bool Source # isInfinite :: Const a b -> Bool Source # isDenormalized :: Const a b -> Bool Source # isNegativeZero :: Const a b -> Bool Source # isIEEE :: Const a b -> Bool Source # atan2 :: Const a b -> Const a b -> Const a b Source #
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) Source # truncate :: Integral b0 => Const a b -> b0 Source # round :: Integral b0 => Const a b -> b0 Source # ceiling :: Integral b0 => Const a b -> b0 Source # floor :: Integral b0 => Const a b -> b0 Source #
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 Source # show :: Const a b -> String Source # showList :: [ Const a b] -> ShowS Source #
Ix a => Ix ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods range :: ( Const a b, Const a b) -> [ Const a b] Source # index :: ( Const a b, Const a b) -> Const a b -> Int Source # unsafeIndex :: ( Const a b, Const a b) -> Const a b -> Int Source # inRange :: ( Const a b, Const a b) -> Const a b -> Bool Source # rangeSize :: ( Const a b, Const a b) -> Int Source # unsafeRangeSize :: ( Const a b, Const a b) -> Int Source #
IsString a => IsString ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Const a b Source #
Generic ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Associated Types type Rep ( Const a b) :: Type -> Type Source # Methods from :: Const a b -> Rep ( Const a b) x Source # to :: Rep ( Const a b) x -> Const a b Source #
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 Source # sconcat :: NonEmpty ( Const a b) -> Const a b Source # stimes :: Integral b0 => b0 -> Const a b -> Const a b Source #
Monoid a => Monoid ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b Source # mappend :: Const a b -> Const a b -> Const a b Source # mconcat :: [ Const a b] -> Const a b Source #
Hashable a => Hashable ( Const a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int Source # hash :: Const a b -> Int Source #
Storable a => Storable ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int Source # alignment :: Const a b -> Int Source # peekElemOff :: Ptr ( Const a b) -> Int -> IO ( Const a b) Source # pokeElemOff :: Ptr ( Const a b) -> Int -> Const a b -> IO () Source # peekByteOff :: Ptr b0 -> Int -> IO ( Const a b) Source # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () Source # peek :: Ptr ( Const a b) -> IO ( Const a b) Source # poke :: Ptr ( Const a b) -> Const a b -> IO () Source #
Bits a => Bits ( 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 Source # (.\|.) :: Const a b -> Const a b -> Const a b Source # xor :: Const a b -> Const a b -> Const a b Source # complement :: Const a b -> Const a b Source # shift :: Const a b -> Int -> Const a b Source # rotate :: Const a b -> Int -> Const a b Source # zeroBits :: Const a b Source # bit :: Int -> Const a b Source # setBit :: Const a b -> Int -> Const a b Source # clearBit :: Const a b -> Int -> Const a b Source # complementBit :: Const a b -> Int -> Const a b Source # testBit :: Const a b -> Int -> Bool Source # bitSizeMaybe :: Const a b -> Maybe Int Source # bitSize :: Const a b -> Int Source # isSigned :: Const a b -> Bool Source # shiftL :: Const a b -> Int -> Const a b Source # unsafeShiftL :: Const a b -> Int -> Const a b Source # shiftR :: Const a b -> Int -> Const a b Source # unsafeShiftR :: Const a b -> Int -> Const a b Source # rotateL :: Const a b -> Int -> Const a b Source # rotateR :: Const a b -> Int -> Const a b Source # popCount :: Const a b -> Int Source #
FiniteBits a => FiniteBits ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int Source # countLeadingZeros :: Const a b -> Int Source # countTrailingZeros :: Const a b -> Int Source #
NFData a => NFData ( Const a b)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Const a b -> () Source #
Prim a => Prim ( Const a b)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Const a b -> Int# Source # alignment# :: Const a b -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Const a b Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Const a b #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Const a b -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Const a b -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Const a b Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Const a b #) Source # writeOffAddr# :: Addr# -> Int# -> Const a b -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Const a b -> State# s -> State# s Source #
Unbox a => Unbox ( Const a b)
Instance details Defined in Data.Vector.Unboxed.Base
type Rep1 ( Const a :: k -> Type )
Instance details Defined in Data.Functor.Const type Rep1 ( Const a :: k -> Type ) = D1 (' MetaData "Const" "Data.Functor.Const" "base" ' True ) ( C1 (' MetaCons "Const" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getConst") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
newtype MVector s ( Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Const a b) = MV_Const ( MVector s a)
type Rep ( Const a b)
Instance details Defined in Data.Functor.Const type Rep ( Const a b) = D1 (' MetaData "Const" "Data.Functor.Const" "base" ' True ) ( C1 (' MetaCons "Const" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getConst") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
newtype Vector ( Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Const a b) = V_Const ( Vector a)

find :: Foldable t => (a -> Bool ) -> t a -> Maybe a Source #

The find function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

notElem :: ( Foldable t, Eq a) => a -> t a -> Bool infix 4 Source #

notElem is the negation of elem .

minimumBy :: Foldable t => (a -> a -> Ordering ) -> t a -> a Source #

The least element of a non-empty structure with respect to the given comparison function.

maximumBy :: Foldable t => (a -> a -> Ordering ) -> t a -> a Source #

The largest element of a non-empty structure with respect to the given comparison function.

all :: Foldable t => (a -> Bool ) -> t a -> Bool Source #

Determines whether all elements of the structure satisfy the predicate.

any :: Foldable t => (a -> Bool ) -> t a -> Bool Source #

Determines whether any element of the structure satisfies the predicate.

or :: Foldable t => t Bool -> Bool Source #

or returns the disjunction of a container of Bools. For the result to be False , the container must be finite; True , however, results from a True value finitely far from the left end.

and :: Foldable t => t Bool -> Bool Source #

and returns the conjunction of a container of Bools. For the result to be True , the container must be finite; False , however, results from a False value finitely far from the left end.

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] Source #

Map a function over all the elements of a container and concatenate the resulting lists.

concat :: Foldable t => t [a] -> [a] Source #

The concatenation of all the elements of a container of lists.

msum :: ( Foldable t, MonadPlus m) => t (m a) -> m a Source #

The sum of a collection of actions, generalizing concat . As of base 4.8.0.0, msum is just asum , specialized to MonadPlus .

asum :: ( Foldable t, Alternative f) => t (f a) -> f a Source #

The sum of a collection of actions, generalizing concat .

>>> asum [Just "Hello", Nothing, Just "World"]
Just "Hello"

sequence_ :: ( Foldable t, Monad m) => t (m a) -> m () Source #

Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence .

As of base 4.8.0.0, sequence_ is just sequenceA_ , specialized to Monad .

sequenceA_ :: ( Foldable t, Applicative f) => t (f a) -> f () Source #

Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequenceA .

for_ :: ( Foldable t, Applicative f) => t a -> (a -> f b) -> f () Source #

for_ is traverse_ with its arguments flipped. For a version that doesn't ignore the results see for .

>>> for_ [1..4] print
1
2
3
4

traverse_ :: ( Foldable t, Applicative f) => (a -> f b) -> t a -> f () Source #

Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see traverse .

foldlM :: ( Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b Source #

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

foldrM :: ( Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b Source #

Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.

newtype First a Source #

Maybe monoid returning the leftmost non-Nothing value.

First a is isomorphic to Alt Maybe a , but precedes it historically.

>>> getFirst (First (Just "hello") <> First Nothing <> First (Just "world"))
Just "hello"

Use of this type is discouraged. Note the following equivalence:

Data.Monoid.First x === Maybe (Data.Semigroup.First x)

In addition to being equivalent in the structural sense, the two also have Monoid instances that behave the same. This type will be marked deprecated in GHC 8.8, and removed in GHC 8.10. Users are advised to use the variant from Data.Semigroup and wrap it in Maybe .

Constructors

First
Fields getFirst :: Maybe a

Instances

Instances details

Monad First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b Source # (>>) :: First a -> First b -> First b Source # return :: a -> First a Source #
Functor First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> First a -> First b Source # (<$) :: a -> First b -> First a Source #
Applicative First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> First a Source # (<>) :: First (a -> b) -> First a -> First b Source # liftA2 :: (a -> b -> c) -> First a -> First b -> First c Source # (>) :: First a -> First b -> First b Source # (<*) :: First a -> First b -> First a Source #
Foldable First	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => First m -> m Source # foldMap :: Monoid m => (a -> m) -> First a -> m Source # foldMap' :: Monoid m => (a -> m) -> First a -> m Source # foldr :: (a -> b -> b) -> b -> First a -> b Source # foldr' :: (a -> b -> b) -> b -> First a -> b Source # foldl :: (b -> a -> b) -> b -> First a -> b Source # foldl' :: (b -> a -> b) -> b -> First a -> b Source # foldr1 :: (a -> a -> a) -> First a -> a Source # foldl1 :: (a -> a -> a) -> First a -> a Source # toList :: First a -> [a] Source # null :: First a -> Bool Source # length :: First a -> Int Source # elem :: Eq a => a -> First a -> Bool Source # maximum :: Ord a => First a -> a Source # minimum :: Ord a => First a -> a Source # sum :: Num a => First a -> a Source # product :: Num a => First a -> a Source #
Traversable First	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> First a -> f ( First b) Source # sequenceA :: Applicative f => First (f a) -> f ( First a) Source # mapM :: Monad m => (a -> m b) -> First a -> m ( First b) Source # sequence :: Monad m => First (m a) -> m ( First a) Source #
NFData1 First	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> First a -> () Source #
Eq a => Eq ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: First a -> First a -> Bool Source # (/=) :: First a -> First a -> Bool Source #
Ord a => Ord ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: First a -> First a -> Ordering Source # (<) :: First a -> First a -> Bool Source # (<=) :: First a -> First a -> Bool Source # (>) :: First a -> First a -> Bool Source # (>=) :: First a -> First a -> Bool Source # max :: First a -> First a -> First a Source # min :: First a -> First a -> First a Source #
Read a => Read ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS ( First a) Source # readList :: ReadS [ First a] Source # readPrec :: ReadPrec ( First a) Source # readListPrec :: ReadPrec [ First a] Source #
Show a => Show ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> First a -> ShowS Source # show :: First a -> String Source # showList :: [ First a] -> ShowS Source #
Generic ( First a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep ( First a) :: Type -> Type Source # Methods from :: First a -> Rep ( First a) x Source # to :: Rep ( First a) x -> First a Source #
Semigroup ( First a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: First a -> First a -> First a Source # sconcat :: NonEmpty ( First a) -> First a Source # stimes :: Integral b => b -> First a -> First a Source #
Monoid ( First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: First a Source # mappend :: First a -> First a -> First a Source # mconcat :: [ First a] -> First a Source #
NFData a => NFData ( First a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: First a -> () Source #
Generic1 First	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 First :: k -> Type Source # Methods from1 :: forall (a :: k). First a -> Rep1 First a Source # to1 :: forall (a :: k). Rep1 First a -> First a Source #
type Rep ( First a)
Instance details Defined in Data.Monoid type Rep ( First a) = D1 (' MetaData "First" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "First" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getFirst") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe a))))
type Rep1 First
Instance details Defined in Data.Monoid type Rep1 First = D1 (' MetaData "First" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "First" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getFirst") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 Maybe )))

newtype Last a Source #

Maybe monoid returning the rightmost non-Nothing value.

Last a is isomorphic to Dual ( First a) , and thus to Dual ( Alt Maybe a)

>>> getLast (Last (Just "hello") <> Last Nothing <> Last (Just "world"))
Just "world"

Use of this type is discouraged. Note the following equivalence:

Data.Monoid.Last x === Maybe (Data.Semigroup.Last x)

In addition to being equivalent in the structural sense, the two also have Monoid instances that behave the same. This type will be marked deprecated in GHC 8.8, and removed in GHC 8.10. Users are advised to use the variant from Data.Semigroup and wrap it in Maybe .

Constructors

Last
Fields getLast :: Maybe a

Instances

Instances details

Monad Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b Source # (>>) :: Last a -> Last b -> Last b Source # return :: a -> Last a Source #
Functor Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b Source # (<$) :: a -> Last b -> Last a Source #
Applicative Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Last a Source # (<>) :: Last (a -> b) -> Last a -> Last b Source # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source # (>) :: Last a -> Last b -> Last b Source # (<*) :: Last a -> Last b -> Last a Source #
Foldable Last	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m Source # foldMap :: Monoid m => (a -> m) -> Last a -> m Source # foldMap' :: Monoid m => (a -> m) -> Last a -> m Source # foldr :: (a -> b -> b) -> b -> Last a -> b Source # foldr' :: (a -> b -> b) -> b -> Last a -> b Source # foldl :: (b -> a -> b) -> b -> Last a -> b Source # foldl' :: (b -> a -> b) -> b -> Last a -> b Source # foldr1 :: (a -> a -> a) -> Last a -> a Source # foldl1 :: (a -> a -> a) -> Last a -> a Source # toList :: Last a -> [a] Source # null :: Last a -> Bool Source # length :: Last a -> Int Source # elem :: Eq a => a -> Last a -> Bool Source # maximum :: Ord a => Last a -> a Source # minimum :: Ord a => Last a -> a Source # sum :: Num a => Last a -> a Source # product :: Num a => Last a -> a Source #
Traversable Last	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Last a -> f ( Last b) Source # sequenceA :: Applicative f => Last (f a) -> f ( Last a) Source # mapM :: Monad m => (a -> m b) -> Last a -> m ( Last b) Source # sequence :: Monad m => Last (m a) -> m ( Last a) Source #
NFData1 Last	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Last a -> () Source #
Eq a => Eq ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: Last a -> Last a -> Bool Source # (/=) :: Last a -> Last a -> Bool Source #
Ord a => Ord ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: Last a -> Last a -> Ordering Source # (<) :: Last a -> Last a -> Bool Source # (<=) :: Last a -> Last a -> Bool Source # (>) :: Last a -> Last a -> Bool Source # (>=) :: Last a -> Last a -> Bool Source # max :: Last a -> Last a -> Last a Source # min :: Last a -> Last a -> Last a Source #
Read a => Read ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS ( Last a) Source # readList :: ReadS [ Last a] Source # readPrec :: ReadPrec ( Last a) Source # readListPrec :: ReadPrec [ Last a] Source #
Show a => Show ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Last a -> ShowS Source # show :: Last a -> String Source # showList :: [ Last a] -> ShowS Source #
Generic ( Last a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep ( Last a) :: Type -> Type Source # Methods from :: Last a -> Rep ( Last a) x Source # to :: Rep ( Last a) x -> Last a Source #
Semigroup ( Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Last a -> Last a -> Last a Source # sconcat :: NonEmpty ( Last a) -> Last a Source # stimes :: Integral b => b -> Last a -> Last a Source #
Monoid ( Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: Last a Source # mappend :: Last a -> Last a -> Last a Source # mconcat :: [ Last a] -> Last a Source #
NFData a => NFData ( Last a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Last a -> () Source #
Generic1 Last	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 Last :: k -> Type Source # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a Source # to1 :: forall (a :: k). Rep1 Last a -> Last a Source #
type Rep ( Last a)
Instance details Defined in Data.Monoid type Rep ( Last a) = D1 (' MetaData "Last" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "Last" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getLast") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( Maybe a))))
type Rep1 Last
Instance details Defined in Data.Monoid type Rep1 Last = D1 (' MetaData "Last" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "Last" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getLast") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 Maybe )))

newtype Ap (f :: k -> Type ) (a :: k) Source #

This data type witnesses the lifting of a Monoid into an Applicative pointwise.

Since: base-4.12.0.0

Constructors

Ap
Fields getAp :: f a

Instances

Instances details

Generic1 ( Ap f :: k -> Type )	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 ( Ap f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Ap f a -> Rep1 ( Ap f) a Source # to1 :: forall (a :: k0). Rep1 ( Ap f) a -> Ap f a Source #
Monad f => Monad ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b Source # (>>) :: Ap f a -> Ap f b -> Ap f b Source # return :: a -> Ap f a Source #
Functor f => Functor ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Ap f a -> Ap f b Source # (<$) :: a -> Ap f b -> Ap f a Source #
MonadFail f => MonadFail ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fail :: String -> Ap f a Source #
Applicative f => Applicative ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Ap f a Source # (<>) :: Ap f (a -> b) -> Ap f a -> Ap f b Source # liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c Source # (>) :: Ap f a -> Ap f b -> Ap f b Source # (<*) :: Ap f a -> Ap f b -> Ap f a Source #
Foldable f => Foldable ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m Source # foldMap :: Monoid m => (a -> m) -> Ap f a -> m Source # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m Source # foldr :: (a -> b -> b) -> b -> Ap f a -> b Source # foldr' :: (a -> b -> b) -> b -> Ap f a -> b Source # foldl :: (b -> a -> b) -> b -> Ap f a -> b Source # foldl' :: (b -> a -> b) -> b -> Ap f a -> b Source # foldr1 :: (a -> a -> a) -> Ap f a -> a Source # foldl1 :: (a -> a -> a) -> Ap f a -> a Source # toList :: Ap f a -> [a] Source # null :: Ap f a -> Bool Source # length :: Ap f a -> Int Source # elem :: Eq a => a -> Ap f a -> Bool Source # maximum :: Ord a => Ap f a -> a Source # minimum :: Ord a => Ap f a -> a Source # sum :: Num a => Ap f a -> a Source # product :: Num a => Ap f a -> a Source #
Traversable f => Traversable ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Ap f a -> f0 ( Ap f b) Source # sequenceA :: Applicative f0 => Ap f (f0 a) -> f0 ( Ap f a) Source # mapM :: Monad m => (a -> m b) -> Ap f a -> m ( Ap f b) Source # sequence :: Monad m => Ap f (m a) -> m ( Ap f a) Source #
Alternative f => Alternative ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods empty :: Ap f a Source # (<\|>) :: Ap f a -> Ap f a -> Ap f a Source # some :: Ap f a -> Ap f [a] Source # many :: Ap f a -> Ap f [a] Source #
MonadPlus f => MonadPlus ( Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mzero :: Ap f a Source # mplus :: Ap f a -> Ap f a -> Ap f a Source #
( Applicative f, Bounded a) => Bounded ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods minBound :: Ap f a Source # maxBound :: Ap f a Source #
Enum (f a) => Enum ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods succ :: Ap f a -> Ap f a Source # pred :: Ap f a -> Ap f a Source # toEnum :: Int -> Ap f a Source # fromEnum :: Ap f a -> Int Source # enumFrom :: Ap f a -> [ Ap f a] Source # enumFromThen :: Ap f a -> Ap f a -> [ Ap f a] Source # enumFromTo :: Ap f a -> Ap f a -> [ Ap f a] Source # enumFromThenTo :: Ap f a -> Ap f a -> Ap f a -> [ Ap f a] Source #
Eq (f a) => Eq ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (==) :: Ap f a -> Ap f a -> Bool Source # (/=) :: Ap f a -> Ap f a -> Bool Source #
( Applicative f, Num a) => Num ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (+) :: Ap f a -> Ap f a -> Ap f a Source # (-) :: Ap f a -> Ap f a -> Ap f a Source # (*) :: Ap f a -> Ap f a -> Ap f a Source # negate :: Ap f a -> Ap f a Source # abs :: Ap f a -> Ap f a Source # signum :: Ap f a -> Ap f a Source # fromInteger :: Integer -> Ap f a Source #
Ord (f a) => Ord ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods compare :: Ap f a -> Ap f a -> Ordering Source # (<) :: Ap f a -> Ap f a -> Bool Source # (<=) :: Ap f a -> Ap f a -> Bool Source # (>) :: Ap f a -> Ap f a -> Bool Source # (>=) :: Ap f a -> Ap f a -> Bool Source # max :: Ap f a -> Ap f a -> Ap f a Source # min :: Ap f a -> Ap f a -> Ap f a Source #
Read (f a) => Read ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS ( Ap f a) Source # readList :: ReadS [ Ap f a] Source # readPrec :: ReadPrec ( Ap f a) Source # readListPrec :: ReadPrec [ Ap f a] Source #
Show (f a) => Show ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Ap f a -> ShowS Source # show :: Ap f a -> String Source # showList :: [ Ap f a] -> ShowS Source #
Generic ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Associated Types type Rep ( Ap f a) :: Type -> Type Source # Methods from :: Ap f a -> Rep ( Ap f a) x Source # to :: Rep ( Ap f a) x -> Ap f a Source #
( Applicative f, Semigroup a) => Semigroup ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Ap f a -> Ap f a -> Ap f a Source # sconcat :: NonEmpty ( Ap f a) -> Ap f a Source # stimes :: Integral b => b -> Ap f a -> Ap f a Source #
( Applicative f, Monoid a) => Monoid ( Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mempty :: Ap f a Source # mappend :: Ap f a -> Ap f a -> Ap f a Source # mconcat :: [ Ap f a] -> Ap f a Source #
type Rep1 ( Ap f :: k -> Type )
Instance details Defined in Data.Monoid type Rep1 ( Ap f :: k -> Type ) = D1 (' MetaData "Ap" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "Ap" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAp") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 f)))
type Rep ( Ap f a)
Instance details Defined in Data.Monoid type Rep ( Ap f a) = D1 (' MetaData "Ap" "Data.Monoid" "base" ' True ) ( C1 (' MetaCons "Ap" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAp") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a))))

stimesMonoid :: ( Integral b, Monoid a) => b -> a -> a Source #

This is a valid definition of stimes for a Monoid .

Unlike the default definition of stimes , it is defined for 0 and so it should be preferred where possible.

stimesIdempotent :: Integral b => b -> a -> a Source #

This is a valid definition of stimes for an idempotent Semigroup .

When x <> x = x , this definition should be preferred, because it works in $\mathcal{O}(1)$ rather than $\mathcal{O}(\log n)$ .

newtype Dual a Source #

The dual of a Monoid , obtained by swapping the arguments of mappend .

>>> getDual (mappend (Dual "Hello") (Dual "World"))
"WorldHello"

Constructors

Dual
Fields getDual :: a

Instances

Instances details

Monad Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b Source # (>>) :: Dual a -> Dual b -> Dual b Source # return :: a -> Dual a Source #
Functor Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Dual a -> Dual b Source # (<$) :: a -> Dual b -> Dual a Source #
Applicative Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Dual a Source # (<>) :: Dual (a -> b) -> Dual a -> Dual b Source # liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c Source # (>) :: Dual a -> Dual b -> Dual b Source # (<*) :: Dual a -> Dual b -> Dual a Source #
Foldable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m Source # foldMap :: Monoid m => (a -> m) -> Dual a -> m Source # foldMap' :: Monoid m => (a -> m) -> Dual a -> m Source # foldr :: (a -> b -> b) -> b -> Dual a -> b Source # foldr' :: (a -> b -> b) -> b -> Dual a -> b Source # foldl :: (b -> a -> b) -> b -> Dual a -> b Source # foldl' :: (b -> a -> b) -> b -> Dual a -> b Source # foldr1 :: (a -> a -> a) -> Dual a -> a Source # foldl1 :: (a -> a -> a) -> Dual a -> a Source # toList :: Dual a -> [a] Source # null :: Dual a -> Bool Source # length :: Dual a -> Int Source # elem :: Eq a => a -> Dual a -> Bool Source # maximum :: Ord a => Dual a -> a Source # minimum :: Ord a => Dual a -> a Source # sum :: Num a => Dual a -> a Source # product :: Num a => Dual a -> a Source #
Traversable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f ( Dual b) Source # sequenceA :: Applicative f => Dual (f a) -> f ( Dual a) Source # mapM :: Monad m => (a -> m b) -> Dual a -> m ( Dual b) Source # sequence :: Monad m => Dual (m a) -> m ( Dual a) Source #
NFData1 Dual	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Dual a -> () Source #
Unbox a => Vector Vector ( Dual a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Dual a) -> m ( Vector ( Dual a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Dual a) -> m ( Mutable Vector ( PrimState m) ( Dual a)) Source # basicLength :: Vector ( Dual a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Dual a) -> Vector ( Dual a) Source # basicUnsafeIndexM :: Monad m => Vector ( Dual a) -> Int -> m ( Dual a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Dual a) -> Vector ( Dual a) -> m () Source # elemseq :: Vector ( Dual a) -> Dual a -> b -> b Source #
Unbox a => MVector MVector ( Dual a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Dual a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Dual a) -> MVector s ( Dual a) Source # basicOverlaps :: MVector s ( Dual a) -> MVector s ( Dual a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Dual a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Dual a -> m ( MVector ( PrimState m) ( Dual a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> Int -> m ( Dual a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> Int -> Dual a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> Dual a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> MVector ( PrimState m) ( Dual a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> MVector ( PrimState m) ( Dual a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Dual a) -> Int -> m ( MVector ( PrimState m) ( Dual a)) Source #
Bounded a => Bounded ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Dual a Source # maxBound :: Dual a Source #
Eq a => Eq ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Dual a -> Dual a -> Bool Source # (/=) :: Dual a -> Dual a -> Bool Source #
Ord a => Ord ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Dual a -> Dual a -> Ordering Source # (<) :: Dual a -> Dual a -> Bool Source # (<=) :: Dual a -> Dual a -> Bool Source # (>) :: Dual a -> Dual a -> Bool Source # (>=) :: Dual a -> Dual a -> Bool Source # max :: Dual a -> Dual a -> Dual a Source # min :: Dual a -> Dual a -> Dual a Source #
Read a => Read ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Dual a) Source # readList :: ReadS [ Dual a] Source # readPrec :: ReadPrec ( Dual a) Source # readListPrec :: ReadPrec [ Dual a] Source #
Show a => Show ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Dual a -> ShowS Source # show :: Dual a -> String Source # showList :: [ Dual a] -> ShowS Source #
Generic ( Dual a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Dual a) :: Type -> Type Source # Methods from :: Dual a -> Rep ( Dual a) x Source # to :: Rep ( Dual a) x -> Dual a Source #
Semigroup a => Semigroup ( Dual a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Dual a -> Dual a -> Dual a Source # sconcat :: NonEmpty ( Dual a) -> Dual a Source # stimes :: Integral b => b -> Dual a -> Dual a Source #
Monoid a => Monoid ( Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Dual a Source # mappend :: Dual a -> Dual a -> Dual a Source # mconcat :: [ Dual a] -> Dual a Source #
NFData a => NFData ( Dual a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Dual a -> () Source #
Prim a => Prim ( Dual a)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Dual a -> Int# Source # alignment# :: Dual a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Dual a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Dual a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Dual a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Dual a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Dual a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Dual a #) Source # writeOffAddr# :: Addr# -> Int# -> Dual a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Dual a -> State# s -> State# s Source #
Unbox a => Unbox ( Dual a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Dual	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Dual :: k -> Type Source # Methods from1 :: forall (a :: k). Dual a -> Rep1 Dual a Source # to1 :: forall (a :: k). Rep1 Dual a -> Dual a Source #
newtype MVector s ( Dual a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Dual a) = MV_Dual ( MVector s a)
type Rep ( Dual a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Dual a) = D1 (' MetaData "Dual" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Dual" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getDual") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
newtype Vector ( Dual a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Dual a) = V_Dual ( Vector a)
type Rep1 Dual
Instance details Defined in Data.Semigroup.Internal type Rep1 Dual = D1 (' MetaData "Dual" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Dual" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getDual") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 ))

newtype Endo a Source #

The monoid of endomorphisms under composition.

>>> let computation = Endo ("Hello, " ++) <> Endo (++ "!")
>>> appEndo computation "Haskell"
"Hello, Haskell!"

Constructors

Endo
Fields appEndo :: a -> a

Instances

Instances details

Generic ( Endo a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Endo a) :: Type -> Type Source # Methods from :: Endo a -> Rep ( Endo a) x Source # to :: Rep ( Endo a) x -> Endo a Source #
Semigroup ( Endo a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Endo a -> Endo a -> Endo a Source # sconcat :: NonEmpty ( Endo a) -> Endo a Source # stimes :: Integral b => b -> Endo a -> Endo a Source #
Monoid ( Endo a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Endo a Source # mappend :: Endo a -> Endo a -> Endo a Source # mconcat :: [ Endo a] -> Endo a Source #
type Rep ( Endo a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Endo a) = D1 (' MetaData "Endo" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Endo" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "appEndo") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (a -> a))))

newtype All Source #

Boolean monoid under conjunction ( && ).

>>> getAll (All True <> mempty <> All False)
False

>>> getAll (mconcat (map (\x -> All (even x)) [2,4,6,7,8]))
False

Constructors

All
Fields getAll :: Bool

Instances

Instances details

Bounded All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: All Source # maxBound :: All Source #
Eq All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: All -> All -> Bool Source # (/=) :: All -> All -> Bool Source #
Ord All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: All -> All -> Ordering Source # (<) :: All -> All -> Bool Source # (<=) :: All -> All -> Bool Source # (>) :: All -> All -> Bool Source # (>=) :: All -> All -> Bool Source # max :: All -> All -> All Source # min :: All -> All -> All Source #
Read All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS All Source # readList :: ReadS [ All ] Source # readPrec :: ReadPrec All Source # readListPrec :: ReadPrec [ All ] Source #
Show All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> All -> ShowS Source # show :: All -> String Source # showList :: [ All ] -> ShowS Source #
Generic All	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type Source # Methods from :: All -> Rep All x Source # to :: Rep All x -> All Source #
Semigroup All	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: All -> All -> All Source # sconcat :: NonEmpty All -> All Source # stimes :: Integral b => b -> All -> All Source #
Monoid All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: All Source # mappend :: All -> All -> All Source # mconcat :: [ All ] -> All Source #
NFData All	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: All -> () Source #
Unbox All
Instance details Defined in Data.Vector.Unboxed.Base
Vector Vector All
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) All -> m ( Vector All ) Source # basicUnsafeThaw :: PrimMonad m => Vector All -> m ( Mutable Vector ( PrimState m) All ) Source # basicLength :: Vector All -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All Source # basicUnsafeIndexM :: Monad m => Vector All -> Int -> m All Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) All -> Vector All -> m () Source # elemseq :: Vector All -> All -> b -> b Source #
MVector MVector All
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s All -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s All -> MVector s All Source # basicOverlaps :: MVector s All -> MVector s All -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) All ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) All -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> All -> m ( MVector ( PrimState m) All ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) All -> Int -> m All Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) All -> Int -> All -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) All -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) All -> All -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) All -> MVector ( PrimState m) All -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) All -> MVector ( PrimState m) All -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) All -> Int -> m ( MVector ( PrimState m) All ) Source #
type Rep All
Instance details Defined in Data.Semigroup.Internal type Rep All = D1 (' MetaData "All" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "All" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAll") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Bool )))
newtype Vector All
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector All = V_All ( Vector Bool )
newtype MVector s All
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s All = MV_All ( MVector s Bool )

newtype Any Source #

Boolean monoid under disjunction ( || ).

>>> getAny (Any True <> mempty <> Any False)
True

>>> getAny (mconcat (map (\x -> Any (even x)) [2,4,6,7,8]))
True

Constructors

Any
Fields getAny :: Bool

Instances

Instances details

Bounded Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Any Source # maxBound :: Any Source #
Eq Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Any -> Any -> Bool Source # (/=) :: Any -> Any -> Bool Source #
Ord Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Any -> Any -> Ordering Source # (<) :: Any -> Any -> Bool Source # (<=) :: Any -> Any -> Bool Source # (>) :: Any -> Any -> Bool Source # (>=) :: Any -> Any -> Bool Source # max :: Any -> Any -> Any Source # min :: Any -> Any -> Any Source #
Read Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS Any Source # readList :: ReadS [ Any ] Source # readPrec :: ReadPrec Any Source # readListPrec :: ReadPrec [ Any ] Source #
Show Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Any -> ShowS Source # show :: Any -> String Source # showList :: [ Any ] -> ShowS Source #
Generic Any	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type Source # Methods from :: Any -> Rep Any x Source # to :: Rep Any x -> Any Source #
Semigroup Any	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Any -> Any -> Any Source # sconcat :: NonEmpty Any -> Any Source # stimes :: Integral b => b -> Any -> Any Source #
Monoid Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Any Source # mappend :: Any -> Any -> Any Source # mconcat :: [ Any ] -> Any Source #
NFData Any	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Any -> () Source #
Unbox Any
Instance details Defined in Data.Vector.Unboxed.Base
Vector Vector Any
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Any -> m ( Vector Any ) Source # basicUnsafeThaw :: PrimMonad m => Vector Any -> m ( Mutable Vector ( PrimState m) Any ) Source # basicLength :: Vector Any -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any Source # basicUnsafeIndexM :: Monad m => Vector Any -> Int -> m Any Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Any -> Vector Any -> m () Source # elemseq :: Vector Any -> Any -> b -> b Source #
MVector MVector Any
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Any -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Any -> MVector s Any Source # basicOverlaps :: MVector s Any -> MVector s Any -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Any ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Any -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Any -> m ( MVector ( PrimState m) Any ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Any -> Int -> m Any Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Any -> Int -> Any -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Any -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Any -> Any -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Any -> MVector ( PrimState m) Any -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Any -> MVector ( PrimState m) Any -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Any -> Int -> m ( MVector ( PrimState m) Any ) Source #
type Rep Any
Instance details Defined in Data.Semigroup.Internal type Rep Any = D1 (' MetaData "Any" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Any" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAny") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Bool )))
newtype Vector Any
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Any = V_Any ( Vector Bool )
newtype MVector s Any
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Any = MV_Any ( MVector s Bool )

newtype Sum a Source #

Monoid under addition.

>>> getSum (Sum 1 <> Sum 2 <> mempty)
3

Constructors

Sum
Fields getSum :: a

Instances

Instances details

Monad Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b Source # (>>) :: Sum a -> Sum b -> Sum b Source # return :: a -> Sum a Source #
Functor Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Sum a -> Sum b Source # (<$) :: a -> Sum b -> Sum a Source #
Applicative Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Sum a Source # (<>) :: Sum (a -> b) -> Sum a -> Sum b Source # liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c Source # (>) :: Sum a -> Sum b -> Sum b Source # (<*) :: Sum a -> Sum b -> Sum a Source #
Foldable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m Source # foldMap :: Monoid m => (a -> m) -> Sum a -> m Source # foldMap' :: Monoid m => (a -> m) -> Sum a -> m Source # foldr :: (a -> b -> b) -> b -> Sum a -> b Source # foldr' :: (a -> b -> b) -> b -> Sum a -> b Source # foldl :: (b -> a -> b) -> b -> Sum a -> b Source # foldl' :: (b -> a -> b) -> b -> Sum a -> b Source # foldr1 :: (a -> a -> a) -> Sum a -> a Source # foldl1 :: (a -> a -> a) -> Sum a -> a Source # toList :: Sum a -> [a] Source # null :: Sum a -> Bool Source # length :: Sum a -> Int Source # elem :: Eq a => a -> Sum a -> Bool Source # maximum :: Ord a => Sum a -> a Source # minimum :: Ord a => Sum a -> a Source # sum :: Num a => Sum a -> a Source # product :: Num a => Sum a -> a Source #
Traversable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f ( Sum b) Source # sequenceA :: Applicative f => Sum (f a) -> f ( Sum a) Source # mapM :: Monad m => (a -> m b) -> Sum a -> m ( Sum b) Source # sequence :: Monad m => Sum (m a) -> m ( Sum a) Source #
NFData1 Sum	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Sum a -> () Source #
Unbox a => Vector Vector ( Sum a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Sum a) -> m ( Vector ( Sum a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Sum a) -> m ( Mutable Vector ( PrimState m) ( Sum a)) Source # basicLength :: Vector ( Sum a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Sum a) -> Vector ( Sum a) Source # basicUnsafeIndexM :: Monad m => Vector ( Sum a) -> Int -> m ( Sum a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Sum a) -> Vector ( Sum a) -> m () Source # elemseq :: Vector ( Sum a) -> Sum a -> b -> b Source #
Unbox a => MVector MVector ( Sum a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Sum a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Sum a) -> MVector s ( Sum a) Source # basicOverlaps :: MVector s ( Sum a) -> MVector s ( Sum a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Sum a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Sum a -> m ( MVector ( PrimState m) ( Sum a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> Int -> m ( Sum a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> Int -> Sum a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> Sum a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> MVector ( PrimState m) ( Sum a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> MVector ( PrimState m) ( Sum a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Sum a) -> Int -> m ( MVector ( PrimState m) ( Sum a)) Source #
Bounded a => Bounded ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Sum a Source # maxBound :: Sum a Source #
Eq a => Eq ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Sum a -> Sum a -> Bool Source # (/=) :: Sum a -> Sum a -> Bool Source #
Num a => Num ( Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Sum a -> Sum a -> Sum a Source # (-) :: Sum a -> Sum a -> Sum a Source # (*) :: Sum a -> Sum a -> Sum a Source # negate :: Sum a -> Sum a Source # abs :: Sum a -> Sum a Source # signum :: Sum a -> Sum a Source # fromInteger :: Integer -> Sum a Source #
Ord a => Ord ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Sum a -> Sum a -> Ordering Source # (<) :: Sum a -> Sum a -> Bool Source # (<=) :: Sum a -> Sum a -> Bool Source # (>) :: Sum a -> Sum a -> Bool Source # (>=) :: Sum a -> Sum a -> Bool Source # max :: Sum a -> Sum a -> Sum a Source # min :: Sum a -> Sum a -> Sum a Source #
Read a => Read ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Sum a) Source # readList :: ReadS [ Sum a] Source # readPrec :: ReadPrec ( Sum a) Source # readListPrec :: ReadPrec [ Sum a] Source #
Show a => Show ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Sum a -> ShowS Source # show :: Sum a -> String Source # showList :: [ Sum a] -> ShowS Source #
Generic ( Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Sum a) :: Type -> Type Source # Methods from :: Sum a -> Rep ( Sum a) x Source # to :: Rep ( Sum a) x -> Sum a Source #
Num a => Semigroup ( Sum a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Sum a -> Sum a -> Sum a Source # sconcat :: NonEmpty ( Sum a) -> Sum a Source # stimes :: Integral b => b -> Sum a -> Sum a Source #
Num a => Monoid ( Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Sum a Source # mappend :: Sum a -> Sum a -> Sum a Source # mconcat :: [ Sum a] -> Sum a Source #
NFData a => NFData ( Sum a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Sum a -> () Source #
Prim a => Prim ( Sum a)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Sum a -> Int# Source # alignment# :: Sum a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Sum a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Sum a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Sum a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Sum a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Sum a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Sum a #) Source # writeOffAddr# :: Addr# -> Int# -> Sum a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Sum a -> State# s -> State# s Source #
Unbox a => Unbox ( Sum a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Sum	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Sum :: k -> Type Source # Methods from1 :: forall (a :: k). Sum a -> Rep1 Sum a Source # to1 :: forall (a :: k). Rep1 Sum a -> Sum a Source #
newtype MVector s ( Sum a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Sum a) = MV_Sum ( MVector s a)
type Rep ( Sum a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Sum a) = D1 (' MetaData "Sum" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Sum" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getSum") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
newtype Vector ( Sum a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Sum a) = V_Sum ( Vector a)
type Rep1 Sum
Instance details Defined in Data.Semigroup.Internal type Rep1 Sum = D1 (' MetaData "Sum" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Sum" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getSum") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 ))

newtype Product a Source #

Monoid under multiplication.

>>> getProduct (Product 3 <> Product 4 <> mempty)
12

Constructors

Product
Fields getProduct :: a

Instances

Instances details

Monad Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Product a -> (a -> Product b) -> Product b Source # (>>) :: Product a -> Product b -> Product b Source # return :: a -> Product a Source #
Functor Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Product a -> Product b Source # (<$) :: a -> Product b -> Product a Source #
Applicative Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Product a Source # (<>) :: Product (a -> b) -> Product a -> Product b Source # liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c Source # (>) :: Product a -> Product b -> Product b Source # (<*) :: Product a -> Product b -> Product a Source #
Foldable Product	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m Source # foldMap :: Monoid m => (a -> m) -> Product a -> m Source # foldMap' :: Monoid m => (a -> m) -> Product a -> m Source # foldr :: (a -> b -> b) -> b -> Product a -> b Source # foldr' :: (a -> b -> b) -> b -> Product a -> b Source # foldl :: (b -> a -> b) -> b -> Product a -> b Source # foldl' :: (b -> a -> b) -> b -> Product a -> b Source # foldr1 :: (a -> a -> a) -> Product a -> a Source # foldl1 :: (a -> a -> a) -> Product a -> a Source # toList :: Product a -> [a] Source # null :: Product a -> Bool Source # length :: Product a -> Int Source # elem :: Eq a => a -> Product a -> Bool Source # maximum :: Ord a => Product a -> a Source # minimum :: Ord a => Product a -> a Source # sum :: Num a => Product a -> a Source # product :: Num a => Product a -> a Source #
Traversable Product	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Product a -> f ( Product b) Source # sequenceA :: Applicative f => Product (f a) -> f ( Product a) Source # mapM :: Monad m => (a -> m b) -> Product a -> m ( Product b) Source # sequence :: Monad m => Product (m a) -> m ( Product a) Source #
NFData1 Product	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Product a -> () Source #
Unbox a => Vector Vector ( Product a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Product a) -> m ( Vector ( Product a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Product a) -> m ( Mutable Vector ( PrimState m) ( Product a)) Source # basicLength :: Vector ( Product a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Product a) -> Vector ( Product a) Source # basicUnsafeIndexM :: Monad m => Vector ( Product a) -> Int -> m ( Product a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Product a) -> Vector ( Product a) -> m () Source # elemseq :: Vector ( Product a) -> Product a -> b -> b Source #
Unbox a => MVector MVector ( Product a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Product a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Product a) -> MVector s ( Product a) Source # basicOverlaps :: MVector s ( Product a) -> MVector s ( Product a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Product a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Product a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Product a -> m ( MVector ( PrimState m) ( Product a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Product a) -> Int -> m ( Product a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Product a) -> Int -> Product a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Product a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Product a) -> Product a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Product a) -> MVector ( PrimState m) ( Product a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Product a) -> MVector ( PrimState m) ( Product a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Product a) -> Int -> m ( MVector ( PrimState m) ( Product a)) Source #
Bounded a => Bounded ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Product a Source # maxBound :: Product a Source #
Eq a => Eq ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Product a -> Product a -> Bool Source # (/=) :: Product a -> Product a -> Bool Source #
Num a => Num ( Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Product a -> Product a -> Product a Source # (-) :: Product a -> Product a -> Product a Source # (*) :: Product a -> Product a -> Product a Source # negate :: Product a -> Product a Source # abs :: Product a -> Product a Source # signum :: Product a -> Product a Source # fromInteger :: Integer -> Product a Source #
Ord a => Ord ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Product a -> Product a -> Ordering Source # (<) :: Product a -> Product a -> Bool Source # (<=) :: Product a -> Product a -> Bool Source # (>) :: Product a -> Product a -> Bool Source # (>=) :: Product a -> Product a -> Bool Source # max :: Product a -> Product a -> Product a Source # min :: Product a -> Product a -> Product a Source #
Read a => Read ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Product a) Source # readList :: ReadS [ Product a] Source # readPrec :: ReadPrec ( Product a) Source # readListPrec :: ReadPrec [ Product a] Source #
Show a => Show ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Product a -> ShowS Source # show :: Product a -> String Source # showList :: [ Product a] -> ShowS Source #
Generic ( Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Product a) :: Type -> Type Source # Methods from :: Product a -> Rep ( Product a) x Source # to :: Rep ( Product a) x -> Product a Source #
Num a => Semigroup ( Product a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Product a -> Product a -> Product a Source # sconcat :: NonEmpty ( Product a) -> Product a Source # stimes :: Integral b => b -> Product a -> Product a Source #
Num a => Monoid ( Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Product a Source # mappend :: Product a -> Product a -> Product a Source # mconcat :: [ Product a] -> Product a Source #
NFData a => NFData ( Product a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Product a -> () Source #
Prim a => Prim ( Product a)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Product a -> Int# Source # alignment# :: Product a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Product a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Product a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Product a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Product a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Product a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Product a #) Source # writeOffAddr# :: Addr# -> Int# -> Product a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Product a -> State# s -> State# s Source #
Unbox a => Unbox ( Product a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Product	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Product :: k -> Type Source # Methods from1 :: forall (a :: k). Product a -> Rep1 Product a Source # to1 :: forall (a :: k). Rep1 Product a -> Product a Source #
newtype MVector s ( Product a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Product a) = MV_Product ( MVector s a)
type Rep ( Product a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Product a) = D1 (' MetaData "Product" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Product" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getProduct") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
newtype Vector ( Product a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Product a) = V_Product ( Vector a)
type Rep1 Product
Instance details Defined in Data.Semigroup.Internal type Rep1 Product = D1 (' MetaData "Product" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Product" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getProduct") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 ))

newtype Alt (f :: k -> Type ) (a :: k) Source #

Monoid under <|> .

>>> getAlt (Alt (Just 12) <> Alt (Just 24))
Just 12

>>> getAlt $ Alt Nothing <> Alt (Just 24)
Just 24

Since: base-4.8.0.0

Constructors

Alt
Fields getAlt :: f a

Instances

Instances details

Generic1 ( Alt f :: k -> Type )	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 ( Alt f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Alt f a -> Rep1 ( Alt f) a Source # to1 :: forall (a :: k0). Rep1 ( Alt f) a -> Alt f a Source #
Unbox (f a) => Vector Vector ( Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Alt f a) -> m ( Vector ( Alt f a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Alt f a) -> m ( Mutable Vector ( PrimState m) ( Alt f a)) Source # basicLength :: Vector ( Alt f a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Alt f a) -> Vector ( Alt f a) Source # basicUnsafeIndexM :: Monad m => Vector ( Alt f a) -> Int -> m ( Alt f a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Alt f a) -> Vector ( Alt f a) -> m () Source # elemseq :: Vector ( Alt f a) -> Alt f a -> b -> b Source #
Unbox (f a) => MVector MVector ( Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Alt f a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Alt f a) -> MVector s ( Alt f a) Source # basicOverlaps :: MVector s ( Alt f a) -> MVector s ( Alt f a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Alt f a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Alt f a -> m ( MVector ( PrimState m) ( Alt f a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> Int -> m ( Alt f a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> Int -> Alt f a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> Alt f a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> MVector ( PrimState m) ( Alt f a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> MVector ( PrimState m) ( Alt f a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Alt f a) -> Int -> m ( MVector ( PrimState m) ( Alt f a)) Source #
Monad f => Monad ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b Source # (>>) :: Alt f a -> Alt f b -> Alt f b Source # return :: a -> Alt f a Source #
Functor f => Functor ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Alt f a -> Alt f b Source # (<$) :: a -> Alt f b -> Alt f a Source #
Applicative f => Applicative ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Alt f a Source # (<>) :: Alt f (a -> b) -> Alt f a -> Alt f b Source # liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c Source # (>) :: Alt f a -> Alt f b -> Alt f b Source # (<*) :: Alt f a -> Alt f b -> Alt f a Source #
Foldable f => Foldable ( Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m Source # foldMap :: Monoid m => (a -> m) -> Alt f a -> m Source # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m Source # foldr :: (a -> b -> b) -> b -> Alt f a -> b Source # foldr' :: (a -> b -> b) -> b -> Alt f a -> b Source # foldl :: (b -> a -> b) -> b -> Alt f a -> b Source # foldl' :: (b -> a -> b) -> b -> Alt f a -> b Source # foldr1 :: (a -> a -> a) -> Alt f a -> a Source # foldl1 :: (a -> a -> a) -> Alt f a -> a Source # toList :: Alt f a -> [a] Source # null :: Alt f a -> Bool Source # length :: Alt f a -> Int Source # elem :: Eq a => a -> Alt f a -> Bool Source # maximum :: Ord a => Alt f a -> a Source # minimum :: Ord a => Alt f a -> a Source # sum :: Num a => Alt f a -> a Source # product :: Num a => Alt f a -> a Source #
Traversable f => Traversable ( Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 ( Alt f b) Source # sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 ( Alt f a) Source # mapM :: Monad m => (a -> m b) -> Alt f a -> m ( Alt f b) Source # sequence :: Monad m => Alt f (m a) -> m ( Alt f a) Source #
Alternative f => Alternative ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods empty :: Alt f a Source # (<\|>) :: Alt f a -> Alt f a -> Alt f a Source # some :: Alt f a -> Alt f [a] Source # many :: Alt f a -> Alt f [a] Source #
MonadPlus f => MonadPlus ( Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mzero :: Alt f a Source # mplus :: Alt f a -> Alt f a -> Alt f a Source #
Enum (f a) => Enum ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods succ :: Alt f a -> Alt f a Source # pred :: Alt f a -> Alt f a Source # toEnum :: Int -> Alt f a Source # fromEnum :: Alt f a -> Int Source # enumFrom :: Alt f a -> [ Alt f a] Source # enumFromThen :: Alt f a -> Alt f a -> [ Alt f a] Source # enumFromTo :: Alt f a -> Alt f a -> [ Alt f a] Source # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [ Alt f a] Source #
Eq (f a) => Eq ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Alt f a -> Alt f a -> Bool Source # (/=) :: Alt f a -> Alt f a -> Bool Source #
Num (f a) => Num ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Alt f a -> Alt f a -> Alt f a Source # (-) :: Alt f a -> Alt f a -> Alt f a Source # (*) :: Alt f a -> Alt f a -> Alt f a Source # negate :: Alt f a -> Alt f a Source # abs :: Alt f a -> Alt f a Source # signum :: Alt f a -> Alt f a Source # fromInteger :: Integer -> Alt f a Source #
Ord (f a) => Ord ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods compare :: Alt f a -> Alt f a -> Ordering Source # (<) :: Alt f a -> Alt f a -> Bool Source # (<=) :: Alt f a -> Alt f a -> Bool Source # (>) :: Alt f a -> Alt f a -> Bool Source # (>=) :: Alt f a -> Alt f a -> Bool Source # max :: Alt f a -> Alt f a -> Alt f a Source # min :: Alt f a -> Alt f a -> Alt f a Source #
Read (f a) => Read ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS ( Alt f a) Source # readList :: ReadS [ Alt f a] Source # readPrec :: ReadPrec ( Alt f a) Source # readListPrec :: ReadPrec [ Alt f a] Source #
Show (f a) => Show ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Alt f a -> ShowS Source # show :: Alt f a -> String Source # showList :: [ Alt f a] -> ShowS Source #
Generic ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep ( Alt f a) :: Type -> Type Source # Methods from :: Alt f a -> Rep ( Alt f a) x Source # to :: Rep ( Alt f a) x -> Alt f a Source #
Alternative f => Semigroup ( Alt f a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Alt f a -> Alt f a -> Alt f a Source # sconcat :: NonEmpty ( Alt f a) -> Alt f a Source # stimes :: Integral b => b -> Alt f a -> Alt f a Source #
Alternative f => Monoid ( Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Alt f a Source # mappend :: Alt f a -> Alt f a -> Alt f a Source # mconcat :: [ Alt f a] -> Alt f a Source #
Unbox (f a) => Unbox ( Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base
type Rep1 ( Alt f :: k -> Type )
Instance details Defined in Data.Semigroup.Internal type Rep1 ( Alt f :: k -> Type ) = D1 (' MetaData "Alt" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Alt" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAlt") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 f)))
newtype MVector s ( Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Alt f a) = MV_Alt ( MVector s (f a))
type Rep ( Alt f a)
Instance details Defined in Data.Semigroup.Internal type Rep ( Alt f a) = D1 (' MetaData "Alt" "Data.Semigroup.Internal" "base" ' True ) ( C1 (' MetaCons "Alt" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getAlt") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a))))
newtype Vector ( Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Alt f a) = V_Alt ( Vector (f a))

data Fixity Source #

Datatype to represent the fixity of a constructor. An infix | declaration directly corresponds to an application of Infix .

Constructors

Prefix
Infix Associativity Int

Instances

Instances details

Eq Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Fixity -> Fixity -> Bool Source # (/=) :: Fixity -> Fixity -> Bool Source #
Ord Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Fixity -> Fixity -> Ordering Source # (<) :: Fixity -> Fixity -> Bool Source # (<=) :: Fixity -> Fixity -> Bool Source # (>) :: Fixity -> Fixity -> Bool Source # (>=) :: Fixity -> Fixity -> Bool Source # max :: Fixity -> Fixity -> Fixity Source # min :: Fixity -> Fixity -> Fixity Source #
Read Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Fixity Source # readList :: ReadS [ Fixity ] Source # readPrec :: ReadPrec Fixity Source # readListPrec :: ReadPrec [ Fixity ] Source #
Show Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Fixity -> ShowS Source # show :: Fixity -> String Source # showList :: [ Fixity ] -> ShowS Source #
Generic Fixity	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
type Rep Fixity
Instance details Defined in GHC.Generics type Rep Fixity = D1 (' MetaData "Fixity" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "Prefix" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "Infix" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Associativity ) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 Int )))

data FixityI Source #

This variant of Fixity appears at the type level.

Since: base-4.9.0.0

Constructors

PrefixI
InfixI Associativity Nat

Instances

Instances details

SingKind FixityI	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep FixityI Methods fromSing :: forall (a :: FixityI ). Sing a -> DemoteRep FixityI
SingI ' PrefixI	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing ' PrefixI
(SingI a, KnownNat n) => SingI (' InfixI a n :: FixityI )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing (' InfixI a n)
type DemoteRep FixityI
Instance details Defined in GHC.Generics type DemoteRep FixityI = Fixity
data Sing (a :: FixityI )
Instance details Defined in GHC.Generics data Sing (a :: FixityI ) where SPrefix :: Sing ' PrefixI SInfix :: forall (a1 :: Associativity ) (n :: Nat ). Sing a1 -> Integer -> Sing (' InfixI a1 n)

data Associativity Source #

Datatype to represent the associativity of a constructor

Constructors

LeftAssociative
RightAssociative
NotAssociative

Instances

Instances details

Bounded Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: Associativity Source # maxBound :: Associativity Source #
Enum Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity Source # pred :: Associativity -> Associativity Source # toEnum :: Int -> Associativity Source # fromEnum :: Associativity -> Int Source # enumFrom :: Associativity -> [ Associativity ] Source # enumFromThen :: Associativity -> Associativity -> [ Associativity ] Source # enumFromTo :: Associativity -> Associativity -> [ Associativity ] Source # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [ Associativity ] Source #
Eq Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool Source # (/=) :: Associativity -> Associativity -> Bool Source #
Ord Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering Source # (<) :: Associativity -> Associativity -> Bool Source # (<=) :: Associativity -> Associativity -> Bool Source # (>) :: Associativity -> Associativity -> Bool Source # (>=) :: Associativity -> Associativity -> Bool Source # max :: Associativity -> Associativity -> Associativity Source # min :: Associativity -> Associativity -> Associativity Source #
Read Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Associativity Source # readList :: ReadS [ Associativity ] Source # readPrec :: ReadPrec Associativity Source # readListPrec :: ReadPrec [ Associativity ] Source #
Show Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Associativity -> ShowS Source # show :: Associativity -> String Source # showList :: [ Associativity ] -> ShowS Source #
Ix Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods range :: ( Associativity , Associativity ) -> [ Associativity ] Source # index :: ( Associativity , Associativity ) -> Associativity -> Int Source # unsafeIndex :: ( Associativity , Associativity ) -> Associativity -> Int Source # inRange :: ( Associativity , Associativity ) -> Associativity -> Bool Source # rangeSize :: ( Associativity , Associativity ) -> Int Source # unsafeRangeSize :: ( Associativity , Associativity ) -> Int Source #
Generic Associativity	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type Source # Methods from :: Associativity -> Rep Associativity x Source # to :: Rep Associativity x -> Associativity Source #
SingKind Associativity	Since: base-4.0.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep Associativity Methods fromSing :: forall (a :: Associativity ). Sing a -> DemoteRep Associativity
SingI ' LeftAssociative	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing ' LeftAssociative
SingI ' RightAssociative	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing ' RightAssociative
SingI ' NotAssociative	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing ' NotAssociative
type Rep Associativity
Instance details Defined in GHC.Generics type Rep Associativity = D1 (' MetaData "Associativity" "GHC.Generics" "base" ' False ) ( C1 (' MetaCons "LeftAssociative" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: ( C1 (' MetaCons "RightAssociative" ' PrefixI ' False ) ( U1 :: Type -> Type ) :+: C1 (' MetaCons "NotAssociative" ' PrefixI ' False ) ( U1 :: Type -> Type )))
type DemoteRep Associativity
Instance details Defined in GHC.Generics type DemoteRep Associativity = Associativity
data Sing (a :: Associativity )
Instance details Defined in GHC.Generics data Sing (a :: Associativity ) where SLeftAssociative :: Sing ' LeftAssociative SRightAssociative :: Sing ' RightAssociative SNotAssociative :: Sing ' NotAssociative

data Meta Source #

Datatype to represent metadata associated with a datatype ( MetaData ), constructor ( MetaCons ), or field selector ( MetaSel ).

In MetaData n m p nt , n is the datatype's name, m is the module in which the datatype is defined, p is the package in which the datatype is defined, and nt is 'True if the datatype is a newtype .
In MetaCons n f s , n is the constructor's name, f is its fixity, and s is 'True if the constructor contains record selectors.
In MetaSel mn su ss ds , if the field uses record syntax, then mn is Just the record name. Otherwise, mn is Nothing . su and ss are the field's unpackedness and strictness annotations, and ds is the strictness that GHC infers for the field.

Since: base-4.9.0.0

Constructors

MetaData Symbol Symbol Symbol Bool
MetaCons Symbol FixityI Bool
MetaSel ( Maybe Symbol ) SourceUnpackedness SourceStrictness DecidedStrictness

Instances

Instances details

( KnownSymbol n, SingI f, SingI r) => Constructor (' MetaCons n f r :: Meta )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods conName :: forall k1 t (f0 :: k1 -> Type ) (a :: k1). t (' MetaCons n f r) f0 a -> [ Char ] Source # conFixity :: forall k1 t (f0 :: k1 -> Type ) (a :: k1). t (' MetaCons n f r) f0 a -> Fixity Source # conIsRecord :: forall k1 t (f0 :: k1 -> Type ) (a :: k1). t (' MetaCons n f r) f0 a -> Bool Source #
( KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI nt) => Datatype (' MetaData n m p nt :: Meta )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods datatypeName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> [ Char ] Source # moduleName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> [ Char ] Source # packageName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> [ Char ] Source # isNewtype :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaData n m p nt) f a -> Bool Source #
(SingI mn, SingI su, SingI ss, SingI ds) => Selector (' MetaSel mn su ss ds :: Meta )	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods selName :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> [ Char ] Source # selSourceUnpackedness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> SourceUnpackedness Source # selSourceStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> SourceStrictness Source # selDecidedStrictness :: forall k1 t (f :: k1 -> Type ) (a :: k1). t (' MetaSel mn su ss ds) f a -> DecidedStrictness Source #

someSymbolVal :: String -> SomeSymbol Source #

Convert a string into an unknown type-level symbol.

Since: base-4.7.0.0

someNatVal :: Integer -> Maybe SomeNat Source #

Convert an integer into an unknown type-level natural.

Since: base-4.7.0.0

symbolVal :: forall (n :: Symbol ) proxy. KnownSymbol n => proxy n -> String Source #

Since: base-4.7.0.0

natVal :: forall (n :: Nat ) proxy. KnownNat n => proxy n -> Integer Source #

Since: base-4.7.0.0

data SomeSymbol Source #

This type represents unknown type-level symbols.

Constructors

KnownSymbol n => SomeSymbol ( Proxy n)

Since: base-4.7.0.0

Instances

Instances details

Eq SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods (==) :: SomeSymbol -> SomeSymbol -> Bool Source # (/=) :: SomeSymbol -> SomeSymbol -> Bool Source #
Ord SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods compare :: SomeSymbol -> SomeSymbol -> Ordering Source # (<) :: SomeSymbol -> SomeSymbol -> Bool Source # (<=) :: SomeSymbol -> SomeSymbol -> Bool Source # (>) :: SomeSymbol -> SomeSymbol -> Bool Source # (>=) :: SomeSymbol -> SomeSymbol -> Bool Source # max :: SomeSymbol -> SomeSymbol -> SomeSymbol Source # min :: SomeSymbol -> SomeSymbol -> SomeSymbol Source #
Read SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods readsPrec :: Int -> ReadS SomeSymbol Source # readList :: ReadS [ SomeSymbol ] Source # readPrec :: ReadPrec SomeSymbol Source # readListPrec :: ReadPrec [ SomeSymbol ] Source #
Show SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods showsPrec :: Int -> SomeSymbol -> ShowS Source # show :: SomeSymbol -> String Source # showList :: [ SomeSymbol ] -> ShowS Source #

data SomeNat Source #

This type represents unknown type-level natural numbers.

Since: base-4.10.0.0

Constructors

KnownNat n => SomeNat ( Proxy n)

Instances

Instances details

Eq SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods (==) :: SomeNat -> SomeNat -> Bool Source # (/=) :: SomeNat -> SomeNat -> Bool Source #
Ord SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods compare :: SomeNat -> SomeNat -> Ordering Source # (<) :: SomeNat -> SomeNat -> Bool Source # (<=) :: SomeNat -> SomeNat -> Bool Source # (>) :: SomeNat -> SomeNat -> Bool Source # (>=) :: SomeNat -> SomeNat -> Bool Source # max :: SomeNat -> SomeNat -> SomeNat Source # min :: SomeNat -> SomeNat -> SomeNat Source #
Read SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods readsPrec :: Int -> ReadS SomeNat Source # readList :: ReadS [ SomeNat ] Source # readPrec :: ReadPrec SomeNat Source # readListPrec :: ReadPrec [ SomeNat ] Source #
Show SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SomeNat -> ShowS Source # show :: SomeNat -> String Source # showList :: [ SomeNat ] -> ShowS Source #

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] Source #

The unfoldr function is a `dual' to foldr : while foldr reduces a list to a summary value, unfoldr builds a list from a seed value. The function takes the element and returns Nothing if it is done producing the list or returns Just (a,b) , in which case, a is a prepended to the list and b is used as the next element in a recursive call. For example,

iterate f == unfoldr (\x -> Just (x, f x))

In some cases, unfoldr can undo a foldr operation:

unfoldr f' (foldr f z xs) == xs

if the following holds:

f' (f x y) = Just (x,y)
f' z       = Nothing

A simple use of unfoldr:

>>> unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
[10,9,8,7,6,5,4,3,2,1]

sortBy :: (a -> a -> Ordering ) -> [a] -> [a] Source #

The sortBy function is the non-overloaded version of sort .

>>> sortBy (\(a,_) (b,_) -> compare a b) [(2, "world"), (4, "!"), (1, "Hello")]
[(1,"Hello"),(2,"world"),(4,"!")]

sort :: Ord a => [a] -> [a] Source #

The sort function implements a stable sorting algorithm. It is a special case of sortBy , which allows the programmer to supply their own comparison function.

Elements are arranged from lowest to highest, keeping duplicates in the order they appeared in the input.

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

permutations :: [a] -> [[a]] Source #

The permutations function returns the list of all permutations of the argument.

>>> permutations "abc"
["abc","bac","cba","bca","cab","acb"]

subsequences :: [a] -> [[a]] Source #

The subsequences function returns the list of all subsequences of the argument.

>>> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]

tails :: [a] -> [[a]] Source #

$\mathcal{O}(n)$ . The tails function returns all final segments of the argument, longest first. For example,

>>> tails "abc"
["abc","bc","c",""]

Note that tails has the following strictness property: tails _|_ = _|_ : _|_

inits :: [a] -> [[a]] Source #

The inits function returns all initial segments of the argument, shortest first. For example,

>>> inits "abc"
["","a","ab","abc"]

Note that inits has the following strictness property: inits (xs ++ _|_) = inits xs ++ _|_

In particular, inits _|_ = [] : _|_

groupBy :: (a -> a -> Bool ) -> [a] -> [[a]] Source #

The groupBy function is the non-overloaded version of group .

group :: Eq a => [a] -> [[a]] Source #

The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

>>> group "Mississippi"
["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy , which allows the programmer to supply their own equality test.

genericReplicate :: Integral i => i -> a -> [a] Source #

The genericReplicate function is an overloaded version of replicate , which accepts any Integral value as the number of repetitions to make.

genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) Source #

The genericSplitAt function is an overloaded version of splitAt , which accepts any Integral value as the position at which to split.

genericDrop :: Integral i => i -> [a] -> [a] Source #

The genericDrop function is an overloaded version of drop , which accepts any Integral value as the number of elements to drop.

genericTake :: Integral i => i -> [a] -> [a] Source #

The genericTake function is an overloaded version of take , which accepts any Integral value as the number of elements to take.

genericLength :: Num i => [a] -> i Source #

$\mathcal{O}(n)$ . The genericLength function is an overloaded version of length . In particular, instead of returning an Int , it returns any type which is an instance of Num . It is, however, less efficient than length .

>>> genericLength [1, 2, 3] :: Int
3
>>> genericLength [1, 2, 3] :: Float
3.0

transpose :: [[a]] -> [[a]] Source #

The transpose function transposes the rows and columns of its argument. For example,

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

If some of the rows are shorter than the following rows, their elements are skipped:

>>> transpose [[10,11],[20],[],[30,31,32]]
[[10,20,30],[11,31],[32]]

intercalate :: [a] -> [[a]] -> [a] Source #

intercalate xs xss is equivalent to ( concat ( intersperse xs xss)) . It inserts the list xs in between the lists in xss and concatenates the result.

>>> intercalate ", " ["Lorem", "ipsum", "dolor"]
"Lorem, ipsum, dolor"

intersperse :: a -> [a] -> [a] Source #

$\mathcal{O}(n)$ . The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example,

>>> intersperse ',' "abcde"
"a,b,c,d,e"

isPrefixOf :: Eq a => [a] -> [a] -> Bool Source #

$\mathcal{O}(\min(m,n))$ . The isPrefixOf function takes two lists and returns True iff the first list is a prefix of the second.

>>> "Hello" `isPrefixOf` "Hello World!"
True

>>> "Hello" `isPrefixOf` "Wello Horld!"
False

isLetter :: Char -> Bool Source #

Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters). This function is equivalent to isAlpha .

This function returns True if its argument has one of the following GeneralCategory s, or False otherwise:

These classes are defined in the Unicode Character Database , part of the Unicode standard. The same document defines what is and is not a "Letter".

Examples

Expand

Basic usage:

>>> isLetter 'a'
True
>>> isLetter 'A'
True
>>> isLetter 'λ'
True
>>> isLetter '0'
False
>>> isLetter '%'
False
>>> isLetter '♥'
False
>>> isLetter '\31'
False

Ensure that isLetter and isAlpha are equivalent.

>>> let chars = [(chr 0)..]
>>> let letters = map isLetter chars
>>> let alphas = map isAlpha chars
>>> letters == alphas
True

digitToInt :: Char -> Int Source #

Convert a single digit Char to the corresponding Int . This function fails unless its argument satisfies isHexDigit , but recognises both upper- and lower-case hexadecimal digits (that is, '0' .. '9' , 'a' .. 'f' , 'A' .. 'F' ).

Examples

Expand

Characters '0' through '9' are converted properly to 0..9 :

>>> map digitToInt ['0'..'9']
[0,1,2,3,4,5,6,7,8,9]

Both upper- and lower-case 'A' through 'F' are converted as well, to 10..15 .

>>> map digitToInt ['a'..'f']
[10,11,12,13,14,15]
>>> map digitToInt ['A'..'F']
[10,11,12,13,14,15]

Anything else throws an exception:

>>> digitToInt 'G'
*** Exception: Char.digitToInt: not a digit 'G'
>>> digitToInt '♥'
*** Exception: Char.digitToInt: not a digit '\9829'

readMaybe :: Read a => String -> Maybe a Source #

Parse a string using the Read instance. Succeeds if there is exactly one valid result.

>>> readMaybe "123" :: Maybe Int
Just 123

>>> readMaybe "hello" :: Maybe Int
Nothing

Since: base-4.6.0.0

readEither :: Read a => String -> Either String a Source #

Parse a string using the Read instance. Succeeds if there is exactly one valid result. A Left value indicates a parse error.

>>> readEither "123" :: Either String Int
Right 123

>>> readEither "hello" :: Either String Int
Left "Prelude.read: no parse"

Since: base-4.6.0.0

reads :: Read a => ReadS a Source #

equivalent to readsPrec with a precedence of 0.

fromRight :: b -> Either a b -> b Source #

Return the contents of a Right -value or a default value otherwise.

Examples

Expand

Basic usage:

>>> fromRight 1 (Right 3)
3
>>> fromRight 1 (Left "foo")
1

Since: base-4.10.0.0

fromLeft :: a -> Either a b -> a Source #

Return the contents of a Left -value or a default value otherwise.

Examples

Expand

Basic usage:

>>> fromLeft 1 (Left 3)
3
>>> fromLeft 1 (Right "foo")
1

Since: base-4.10.0.0

isRight :: Either a b -> Bool Source #

Return True if the given value is a Right -value, False otherwise.

Examples

Expand

Basic usage:

>>> isRight (Left "foo")
False
>>> isRight (Right 3)
True

Assuming a Left value signifies some sort of error, we can use isRight to write a very simple reporting function that only outputs "SUCCESS" when a computation has succeeded.

This example shows how isRight might be used to avoid pattern matching when one does not care about the value contained in the constructor:

>>> import Control.Monad ( when )
>>> let report e = when (isRight e) $ putStrLn "SUCCESS"
>>> report (Left "parse error")
>>> report (Right 1)
SUCCESS

Since: base-4.7.0.0

isLeft :: Either a b -> Bool Source #

Return True if the given value is a Left -value, False otherwise.

Examples

Expand

Basic usage:

>>> isLeft (Left "foo")
True
>>> isLeft (Right 3)
False

Assuming a Left value signifies some sort of error, we can use isLeft to write a very simple error-reporting function that does absolutely nothing in the case of success, and outputs "ERROR" if any error occurred.

This example shows how isLeft might be used to avoid pattern matching when one does not care about the value contained in the constructor:

>>> import Control.Monad ( when )
>>> let report e = when (isLeft e) $ putStrLn "ERROR"
>>> report (Right 1)
>>> report (Left "parse error")
ERROR

Since: base-4.7.0.0

partitionEithers :: [ Either a b] -> ([a], [b]) Source #

Partitions a list of Either into two lists. All the Left elements are extracted, in order, to the first component of the output. Similarly the Right elements are extracted to the second component of the output.

Examples

Expand

Basic usage:

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> partitionEithers list
(["foo","bar","baz"],[3,7])

The pair returned by partitionEithers x should be the same pair as ( lefts x, rights x) :

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> partitionEithers list == (lefts list, rights list)
True

rights :: [ Either a b] -> [b] Source #

Extracts from a list of Either all the Right elements. All the Right elements are extracted in order.

Examples

Expand

Basic usage:

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> rights list
[3,7]

lefts :: [ Either a b] -> [a] Source #

Extracts from a list of Either all the Left elements. All the Left elements are extracted in order.

Examples

Expand

Basic usage:

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> lefts list
["foo","bar","baz"]

either :: (a -> c) -> (b -> c) -> Either a b -> c Source #

Case analysis for the Either type. If the value is Left a , apply the first function to a ; if it is Right b , apply the second function to b .

Examples

Expand

We create two values of type Either String Int , one using the Left constructor and another using the Right constructor. Then we apply "either" the length function (if we have a String ) or the "times-two" function (if we have an Int ):

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> either length (*2) s
3
>>> either length (*2) n
6

comparing :: Ord a => (b -> a) -> b -> b -> Ordering Source #

comparing p x y = compare (p x) (p y)

Useful combinator for use in conjunction with the xxxBy family of functions from Data.List , for example:

  ... sortBy (comparing fst) ...

newtype Down a Source #

The Down type allows you to reverse sort order conveniently. A value of type Down a contains a value of type a (represented as Down a ). If a has an Ord instance associated with it then comparing two values thus wrapped will give you the opposite of their normal sort order. This is particularly useful when sorting in generalised list comprehensions, as in: then sortWith by Down x

Since: base-4.6.0.0

Constructors

Down a

Instances

Instances details

Monad Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b Source # (>>) :: Down a -> Down b -> Down b Source # return :: a -> Down a Source #
Functor Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b Source # (<$) :: a -> Down b -> Down a Source #
Applicative Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods pure :: a -> Down a Source # (<>) :: Down (a -> b) -> Down a -> Down b Source # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c Source # (>) :: Down a -> Down b -> Down b Source # (<*) :: Down a -> Down b -> Down a Source #
Foldable Down	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m Source # foldMap :: Monoid m => (a -> m) -> Down a -> m Source # foldMap' :: Monoid m => (a -> m) -> Down a -> m Source # foldr :: (a -> b -> b) -> b -> Down a -> b Source # foldr' :: (a -> b -> b) -> b -> Down a -> b Source # foldl :: (b -> a -> b) -> b -> Down a -> b Source # foldl' :: (b -> a -> b) -> b -> Down a -> b Source # foldr1 :: (a -> a -> a) -> Down a -> a Source # foldl1 :: (a -> a -> a) -> Down a -> a Source # toList :: Down a -> [a] Source # null :: Down a -> Bool Source # length :: Down a -> Int Source # elem :: Eq a => a -> Down a -> Bool Source # maximum :: Ord a => Down a -> a Source # minimum :: Ord a => Down a -> a Source # sum :: Num a => Down a -> a Source # product :: Num a => Down a -> a Source #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f ( Down b) Source # sequenceA :: Applicative f => Down (f a) -> f ( Down a) Source # mapM :: Monad m => (a -> m b) -> Down a -> m ( Down b) Source # sequence :: Monad m => Down (m a) -> m ( Down a) Source #
NFData1 Down	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Down a -> () Source #
Unbox a => Vector Vector ( Down a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Down a) -> m ( Vector ( Down a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Down a) -> m ( Mutable Vector ( PrimState m) ( Down a)) Source # basicLength :: Vector ( Down a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Down a) -> Vector ( Down a) Source # basicUnsafeIndexM :: Monad m => Vector ( Down a) -> Int -> m ( Down a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Down a) -> Vector ( Down a) -> m () Source # elemseq :: Vector ( Down a) -> Down a -> b -> b Source #
Unbox a => MVector MVector ( Down a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Down a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Down a) -> MVector s ( Down a) Source # basicOverlaps :: MVector s ( Down a) -> MVector s ( Down a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Down a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Down a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Down a -> m ( MVector ( PrimState m) ( Down a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Down a) -> Int -> m ( Down a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Down a) -> Int -> Down a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Down a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Down a) -> Down a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Down a) -> MVector ( PrimState m) ( Down a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Down a) -> MVector ( PrimState m) ( Down a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Down a) -> Int -> m ( MVector ( PrimState m) ( Down a)) Source #
Bounded a => Bounded ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods minBound :: Down a Source # maxBound :: Down a Source #
Enum a => Enum ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods succ :: Down a -> Down a Source # pred :: Down a -> Down a Source # toEnum :: Int -> Down a Source # fromEnum :: Down a -> Int Source # enumFrom :: Down a -> [ Down a] Source # enumFromThen :: Down a -> Down a -> [ Down a] Source # enumFromTo :: Down a -> Down a -> [ Down a] Source # enumFromThenTo :: Down a -> Down a -> Down a -> [ Down a] Source #
Eq a => Eq ( Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods (==) :: Down a -> Down a -> Bool Source # (/=) :: Down a -> Down a -> Bool Source #
Floating a => Floating ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods pi :: Down a Source # exp :: Down a -> Down a Source # log :: Down a -> Down a Source # sqrt :: Down a -> Down a Source # (**) :: Down a -> Down a -> Down a Source # logBase :: Down a -> Down a -> Down a Source # sin :: Down a -> Down a Source # cos :: Down a -> Down a Source # tan :: Down a -> Down a Source # asin :: Down a -> Down a Source # acos :: Down a -> Down a Source # atan :: Down a -> Down a Source # sinh :: Down a -> Down a Source # cosh :: Down a -> Down a Source # tanh :: Down a -> Down a Source # asinh :: Down a -> Down a Source # acosh :: Down a -> Down a Source # atanh :: Down a -> Down a Source # log1p :: Down a -> Down a Source # expm1 :: Down a -> Down a Source # log1pexp :: Down a -> Down a Source # log1mexp :: Down a -> Down a Source #
Fractional a => Fractional ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (/) :: Down a -> Down a -> Down a Source # recip :: Down a -> Down a Source # fromRational :: Rational -> Down a Source #
Integral a => Integral ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods quot :: Down a -> Down a -> Down a Source # rem :: Down a -> Down a -> Down a Source # div :: Down a -> Down a -> Down a Source # mod :: Down a -> Down a -> Down a Source # quotRem :: Down a -> Down a -> ( Down a, Down a) Source # divMod :: Down a -> Down a -> ( Down a, Down a) Source # toInteger :: Down a -> Integer Source #
Num a => Num ( Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (+) :: Down a -> Down a -> Down a Source # (-) :: Down a -> Down a -> Down a Source # (*) :: Down a -> Down a -> Down a Source # negate :: Down a -> Down a Source # abs :: Down a -> Down a Source # signum :: Down a -> Down a Source # fromInteger :: Integer -> Down a Source #
Ord a => Ord ( Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods compare :: Down a -> Down a -> Ordering Source # (<) :: Down a -> Down a -> Bool Source # (<=) :: Down a -> Down a -> Bool Source # (>) :: Down a -> Down a -> Bool Source # (>=) :: Down a -> Down a -> Bool Source # max :: Down a -> Down a -> Down a Source # min :: Down a -> Down a -> Down a Source #
Read a => Read ( Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods readsPrec :: Int -> ReadS ( Down a) Source # readList :: ReadS [ Down a] Source # readPrec :: ReadPrec ( Down a) Source # readListPrec :: ReadPrec [ Down a] Source #
Real a => Real ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods toRational :: Down a -> Rational Source #
RealFloat a => RealFloat ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods floatRadix :: Down a -> Integer Source # floatDigits :: Down a -> Int Source # floatRange :: Down a -> ( Int , Int ) Source # decodeFloat :: Down a -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Down a Source # exponent :: Down a -> Int Source # significand :: Down a -> Down a Source # scaleFloat :: Int -> Down a -> Down a Source # isNaN :: Down a -> Bool Source # isInfinite :: Down a -> Bool Source # isDenormalized :: Down a -> Bool Source # isNegativeZero :: Down a -> Bool Source # isIEEE :: Down a -> Bool Source # atan2 :: Down a -> Down a -> Down a Source #
RealFrac a => RealFrac ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods properFraction :: Integral b => Down a -> (b, Down a) Source # truncate :: Integral b => Down a -> b Source # round :: Integral b => Down a -> b Source # ceiling :: Integral b => Down a -> b Source # floor :: Integral b => Down a -> b Source #
Show a => Show ( Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods showsPrec :: Int -> Down a -> ShowS Source # show :: Down a -> String Source # showList :: [ Down a] -> ShowS Source #
Ix a => Ix ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods range :: ( Down a, Down a) -> [ Down a] Source # index :: ( Down a, Down a) -> Down a -> Int Source # unsafeIndex :: ( Down a, Down a) -> Down a -> Int Source # inRange :: ( Down a, Down a) -> Down a -> Bool Source # rangeSize :: ( Down a, Down a) -> Int Source # unsafeRangeSize :: ( Down a, Down a) -> Int Source #
Generic ( Down a)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Down a) :: Type -> Type Source # Methods from :: Down a -> Rep ( Down a) x Source # to :: Rep ( Down a) x -> Down a Source #
Semigroup a => Semigroup ( Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (<>) :: Down a -> Down a -> Down a Source # sconcat :: NonEmpty ( Down a) -> Down a Source # stimes :: Integral b => b -> Down a -> Down a Source #
Monoid a => Monoid ( Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a Source # mappend :: Down a -> Down a -> Down a Source # mconcat :: [ Down a] -> Down a Source #
Storable a => Storable ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods sizeOf :: Down a -> Int Source # alignment :: Down a -> Int Source # peekElemOff :: Ptr ( Down a) -> Int -> IO ( Down a) Source # pokeElemOff :: Ptr ( Down a) -> Int -> Down a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Down a) Source # pokeByteOff :: Ptr b -> Int -> Down a -> IO () Source # peek :: Ptr ( Down a) -> IO ( Down a) Source # poke :: Ptr ( Down a) -> Down a -> IO () Source #
Bits a => Bits ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (.&.) :: Down a -> Down a -> Down a Source # (.\|.) :: Down a -> Down a -> Down a Source # xor :: Down a -> Down a -> Down a Source # complement :: Down a -> Down a Source # shift :: Down a -> Int -> Down a Source # rotate :: Down a -> Int -> Down a Source # zeroBits :: Down a Source # bit :: Int -> Down a Source # setBit :: Down a -> Int -> Down a Source # clearBit :: Down a -> Int -> Down a Source # complementBit :: Down a -> Int -> Down a Source # testBit :: Down a -> Int -> Bool Source # bitSizeMaybe :: Down a -> Maybe Int Source # bitSize :: Down a -> Int Source # isSigned :: Down a -> Bool Source # shiftL :: Down a -> Int -> Down a Source # unsafeShiftL :: Down a -> Int -> Down a Source # shiftR :: Down a -> Int -> Down a Source # unsafeShiftR :: Down a -> Int -> Down a Source # rotateL :: Down a -> Int -> Down a Source # rotateR :: Down a -> Int -> Down a Source # popCount :: Down a -> Int Source #
FiniteBits a => FiniteBits ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods finiteBitSize :: Down a -> Int Source # countLeadingZeros :: Down a -> Int Source # countTrailingZeros :: Down a -> Int Source #
NFData a => NFData ( Down a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Down a -> () Source #
Prim a => Prim ( Down a)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Down a -> Int# Source # alignment# :: Down a -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Down a Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Down a #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Down a -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Down a -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Down a Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Down a #) Source # writeOffAddr# :: Addr# -> Int# -> Down a -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Down a -> State# s -> State# s Source #
Unbox a => Unbox ( Down a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Down	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Down :: k -> Type Source # Methods from1 :: forall (a :: k). Down a -> Rep1 Down a Source # to1 :: forall (a :: k). Rep1 Down a -> Down a Source #
newtype MVector s ( Down a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s ( Down a) = MV_Down ( MVector s a)
type Rep ( Down a)
Instance details Defined in GHC.Generics type Rep ( Down a) = D1 (' MetaData "Down" "Data.Ord" "base" ' True ) ( C1 (' MetaCons "Down" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getDown") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a)))
newtype Vector ( Down a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Down a) = V_Down ( Vector a)
type Rep1 Down
Instance details Defined in GHC.Generics type Rep1 Down = D1 (' MetaData "Down" "Data.Ord" "base" ' True ) ( C1 (' MetaCons "Down" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getDown") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 ))

data Proxy (t :: k) Source #

Proxy is a type that holds no data, but has a phantom parameter of arbitrary type (or even kind). Its use is to provide type information, even though there is no value available of that type (or it may be too costly to create one).

Historically, Proxy :: Proxy a is a safer alternative to the undefined :: a idiom.

>>> Proxy :: Proxy (Void, Int -> Int)
Proxy

Proxy can even hold types of higher kinds,

>>> Proxy :: Proxy Either
Proxy

>>> Proxy :: Proxy Functor
Proxy

>>> Proxy :: Proxy complicatedStructure
Proxy

Constructors

Proxy

Instances

Instances details

Generic1 ( Proxy :: k -> Type )	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Proxy :: k -> Type Source # Methods from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a Source # to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a Source #
Monad ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b Source # (>>) :: Proxy a -> Proxy b -> Proxy b Source # return :: a -> Proxy a Source #
Functor ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b Source # (<$) :: a -> Proxy b -> Proxy a Source #
Applicative ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods pure :: a -> Proxy a Source # (<>) :: Proxy (a -> b) -> Proxy a -> Proxy b Source # liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c Source # (>) :: Proxy a -> Proxy b -> Proxy b Source # (<*) :: Proxy a -> Proxy b -> Proxy a Source #
Foldable ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m Source # foldMap :: Monoid m => (a -> m) -> Proxy a -> m Source # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m Source # foldr :: (a -> b -> b) -> b -> Proxy a -> b Source # foldr' :: (a -> b -> b) -> b -> Proxy a -> b Source # foldl :: (b -> a -> b) -> b -> Proxy a -> b Source # foldl' :: (b -> a -> b) -> b -> Proxy a -> b Source # foldr1 :: (a -> a -> a) -> Proxy a -> a Source # foldl1 :: (a -> a -> a) -> Proxy a -> a Source # toList :: Proxy a -> [a] Source # null :: Proxy a -> Bool Source # length :: Proxy a -> Int Source # elem :: Eq a => a -> Proxy a -> Bool Source # maximum :: Ord a => Proxy a -> a Source # minimum :: Ord a => Proxy a -> a Source # sum :: Num a => Proxy a -> a Source # product :: Num a => Proxy a -> a Source #
Traversable ( Proxy :: Type -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Proxy a -> f ( Proxy b) Source # sequenceA :: Applicative f => Proxy (f a) -> f ( Proxy a) Source # mapM :: Monad m => (a -> m b) -> Proxy a -> m ( Proxy b) Source # sequence :: Monad m => Proxy (m a) -> m ( Proxy a) Source #
Alternative ( Proxy :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a Source # (<\|>) :: Proxy a -> Proxy a -> Proxy a Source # some :: Proxy a -> Proxy [a] Source # many :: Proxy a -> Proxy [a] Source #
MonadPlus ( Proxy :: Type -> Type )	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods mzero :: Proxy a Source # mplus :: Proxy a -> Proxy a -> Proxy a Source #
NFData1 ( Proxy :: Type -> Type )	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Proxy a -> () Source #
Hashable1 ( Proxy :: Type -> Type )
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Proxy a -> Int Source #
Bounded ( Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t Source # maxBound :: Proxy t Source #
Enum ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods succ :: Proxy s -> Proxy s Source # pred :: Proxy s -> Proxy s Source # toEnum :: Int -> Proxy s Source # fromEnum :: Proxy s -> Int Source # enumFrom :: Proxy s -> [ Proxy s] Source # enumFromThen :: Proxy s -> Proxy s -> [ Proxy s] Source # enumFromTo :: Proxy s -> Proxy s -> [ Proxy s] Source # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [ Proxy s] Source #
Eq ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (==) :: Proxy s -> Proxy s -> Bool Source # (/=) :: Proxy s -> Proxy s -> Bool Source #
Ord ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods compare :: Proxy s -> Proxy s -> Ordering Source # (<) :: Proxy s -> Proxy s -> Bool Source # (<=) :: Proxy s -> Proxy s -> Bool Source # (>) :: Proxy s -> Proxy s -> Bool Source # (>=) :: Proxy s -> Proxy s -> Bool Source # max :: Proxy s -> Proxy s -> Proxy s Source # min :: Proxy s -> Proxy s -> Proxy s Source #
Read ( Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods readsPrec :: Int -> ReadS ( Proxy t) Source # readList :: ReadS [ Proxy t] Source # readPrec :: ReadPrec ( Proxy t) Source # readListPrec :: ReadPrec [ Proxy t] Source #
Show ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods showsPrec :: Int -> Proxy s -> ShowS Source # show :: Proxy s -> String Source # showList :: [ Proxy s] -> ShowS Source #
Ix ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods range :: ( Proxy s, Proxy s) -> [ Proxy s] Source # index :: ( Proxy s, Proxy s) -> Proxy s -> Int Source # unsafeIndex :: ( Proxy s, Proxy s) -> Proxy s -> Int Source # inRange :: ( Proxy s, Proxy s) -> Proxy s -> Bool Source # rangeSize :: ( Proxy s, Proxy s) -> Int Source # unsafeRangeSize :: ( Proxy s, Proxy s) -> Int Source #
Generic ( Proxy t)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( Proxy t) :: Type -> Type Source # Methods from :: Proxy t -> Rep ( Proxy t) x Source # to :: Rep ( Proxy t) x -> Proxy t Source #
Semigroup ( Proxy s)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods (<>) :: Proxy s -> Proxy s -> Proxy s Source # sconcat :: NonEmpty ( Proxy s) -> Proxy s Source # stimes :: Integral b => b -> Proxy s -> Proxy s Source #
Monoid ( Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s Source # mappend :: Proxy s -> Proxy s -> Proxy s Source # mconcat :: [ Proxy s] -> Proxy s Source #
Hashable ( Proxy a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Proxy a -> Int Source # hash :: Proxy a -> Int Source #
NFData ( Proxy a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Proxy a -> () Source #
type Rep1 ( Proxy :: k -> Type )
Instance details Defined in GHC.Generics type Rep1 ( Proxy :: k -> Type ) = D1 (' MetaData "Proxy" "Data.Proxy" "base" ' False ) ( C1 (' MetaCons "Proxy" ' PrefixI ' False ) ( U1 :: k -> Type ))
type Rep ( Proxy t)
Instance details Defined in GHC.Generics type Rep ( Proxy t) = D1 (' MetaData "Proxy" "Data.Proxy" "base" ' False ) ( C1 (' MetaCons "Proxy" ' PrefixI ' False ) ( U1 :: Type -> Type ))

(>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 Source #

Left-to-right composition

(<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 1 Source #

Right-to-left composition

class Category (cat :: k -> k -> Type ) where Source #

A class for categories. Instances should satisfy the laws

Right identity: f . id = f
Left identity: id . f = f
Associativity: f . (g . h) = (f . g) . h

Minimal complete definition

id , (.)

Methods

(.) :: forall (b :: k) (c :: k) (a :: k). cat b c -> cat a b -> cat a c infixr 9 Source #

morphism composition

Instances

Instances details

Category ( Coercion :: k -> k -> Type )	Since: base-4.7.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). Coercion a a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). Coercion b c -> Coercion a b -> Coercion a c Source #
Category ( (:~:) :: k -> k -> Type )	Since: base-4.7.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). a :~: a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). (b :~: c) -> (a :~: b) -> a :~: c Source #
Category ( (:~~:) :: k -> k -> Type )	Since: base-4.10.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). a :~~: a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). (b :~~: c) -> (a :~~: b) -> a :~~: c Source #
( Category p, Category q) => Category ( Product p q :: k -> k -> Type )
Instance details Defined in Data.Bifunctor.Product Methods id :: forall (a :: k0). Product p q a a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). Product p q b c -> Product p q a b -> Product p q a c Source #
( Applicative f, Category p) => Category ( Tannen f p :: k -> k -> Type )
Instance details Defined in Data.Bifunctor.Tannen Methods id :: forall (a :: k0). Tannen f p a a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). Tannen f p b c -> Tannen f p a b -> Tannen f p a c Source #
Category Format	The same as (%). At present using `Category` has an import overhead, but one day it might be imported as standard.
Instance details Defined in Formatting.Internal Methods id :: forall (a :: k). Format a a Source # (.) :: forall (b :: k) (c :: k) (a :: k). Format b c -> Format a b -> Format a c Source #
Monad m => Category ( Kleisli m :: Type -> Type -> Type )	Since: base-3.0
Instance details Defined in Control.Arrow Methods id :: forall (a :: k). Kleisli m a a Source # (.) :: forall (b :: k) (c :: k) (a :: k). Kleisli m b c -> Kleisli m a b -> Kleisli m a c Source #
( Applicative f, Monad f) => Category ( WhenMissing f :: Type -> Type -> Type )	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods id :: forall (a :: k). WhenMissing f a a Source # (.) :: forall (b :: k) (c :: k) (a :: k). WhenMissing f b c -> WhenMissing f a b -> WhenMissing f a c Source #
Category ((->) :: Type -> Type -> Type )	Since: base-3.0
Instance details Defined in Control.Category Methods id :: forall (a :: k). a -> a Source # (.) :: forall (b :: k) (c :: k) (a :: k). (b -> c) -> (a -> b) -> a -> c Source #
( Monad f, Applicative f) => Category ( WhenMatched f x :: Type -> Type -> Type )	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods id :: forall (a :: k). WhenMatched f x a a Source # (.) :: forall (b :: k) (c :: k) (a :: k). WhenMatched f x b c -> WhenMatched f x a b -> WhenMatched f x a c Source #
( Applicative f, Monad f) => Category ( WhenMissing f k :: Type -> Type -> Type )	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods id :: forall (a :: k0). WhenMissing f k a a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). WhenMissing f k b c -> WhenMissing f k a b -> WhenMissing f k a c Source #
( Monad f, Applicative f) => Category ( WhenMatched f k x :: Type -> Type -> Type )	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods id :: forall (a :: k0). WhenMatched f k x a a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). WhenMatched f k x b c -> WhenMatched f k x a b -> WhenMatched f k x a c Source #

repr :: forall k (a :: k) (b :: k). (a :~: b) -> Coercion a b Source #

Convert propositional (nominal) equality to representational equality

coerceWith :: Coercion a b -> a -> b Source #

Type-safe cast, using representational equality

data Coercion (a :: k) (b :: k) where Source #

Representational equality. If Coercion a b is inhabited by some terminating value, then the type a has the same underlying representation as the type b .

To use this equality in practice, pattern-match on the Coercion a b to get out the Coercible a b instance, and then use coerce to apply it.

Since: base-4.7.0.0

Constructors

Coercion :: forall k (a :: k) (b :: k). Coercible a b => Coercion a b

Instances

Instances details

Category ( Coercion :: k -> k -> Type )	Since: base-4.7.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). Coercion a a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). Coercion b c -> Coercion a b -> Coercion a c Source #
TestCoercion ( Coercion a :: k -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods testCoercion :: forall (a0 :: k0) (b :: k0). Coercion a a0 -> Coercion a b -> Maybe ( Coercion a0 b) Source #
Coercible a b => Bounded ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods minBound :: Coercion a b Source # maxBound :: Coercion a b Source #
Coercible a b => Enum ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods succ :: Coercion a b -> Coercion a b Source # pred :: Coercion a b -> Coercion a b Source # toEnum :: Int -> Coercion a b Source # fromEnum :: Coercion a b -> Int Source # enumFrom :: Coercion a b -> [ Coercion a b] Source # enumFromThen :: Coercion a b -> Coercion a b -> [ Coercion a b] Source # enumFromTo :: Coercion a b -> Coercion a b -> [ Coercion a b] Source # enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [ Coercion a b] Source #
Eq ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods (==) :: Coercion a b -> Coercion a b -> Bool Source # (/=) :: Coercion a b -> Coercion a b -> Bool Source #
Ord ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods compare :: Coercion a b -> Coercion a b -> Ordering Source # (<) :: Coercion a b -> Coercion a b -> Bool Source # (<=) :: Coercion a b -> Coercion a b -> Bool Source # (>) :: Coercion a b -> Coercion a b -> Bool Source # (>=) :: Coercion a b -> Coercion a b -> Bool Source # max :: Coercion a b -> Coercion a b -> Coercion a b Source # min :: Coercion a b -> Coercion a b -> Coercion a b Source #
Coercible a b => Read ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods readsPrec :: Int -> ReadS ( Coercion a b) Source # readList :: ReadS [ Coercion a b] Source # readPrec :: ReadPrec ( Coercion a b) Source # readListPrec :: ReadPrec [ Coercion a b] Source #
Show ( Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods showsPrec :: Int -> Coercion a b -> ShowS Source # show :: Coercion a b -> String Source # showList :: [ Coercion a b] -> ShowS Source #

gcastWith :: forall k (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r Source #

Generalized form of type-safe cast using propositional equality

castWith :: (a :~: b) -> a -> b Source #

Type-safe cast, using propositional equality

trans :: forall k (a :: k) (b :: k) (c :: k). (a :~: b) -> (b :~: c) -> a :~: c Source #

Transitivity of equality

sym :: forall k (a :: k) (b :: k). (a :~: b) -> b :~: a Source #

Symmetry of equality

data (a :: k) :~: (b :: k) where infix 4 Source #

Propositional equality. If a :~: b is inhabited by some terminating value, then the type a is the same as the type b . To use this equality in practice, pattern-match on the a :~: b to get out the Refl constructor; in the body of the pattern-match, the compiler knows that a ~ b .

Since: base-4.7.0.0

Constructors

Refl :: forall k (a :: k). a :~: a

Instances

Instances details

Category ( (:~:) :: k -> k -> Type )	Since: base-4.7.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). a :~: a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). (b :~: c) -> (a :~: b) -> a :~: c Source #
TestCoercion ( (:~:) a :: k -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods testCoercion :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe ( Coercion a0 b) Source #
TestEquality ( (:~:) a :: k -> Type )	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b) Source #
NFData2 ( (:~:) :: Type -> Type -> Type )	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> (a :~: b) -> () Source #
NFData1 ( (:~:) a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> (a :~: a0) -> () Source #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b Source # maxBound :: a :~: b Source #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b Source # pred :: (a :~: b) -> a :~: b Source # toEnum :: Int -> a :~: b Source # fromEnum :: (a :~: b) -> Int Source # enumFrom :: (a :~: b) -> [a :~: b] Source # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] Source # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] Source # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] Source #
Eq (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~: b) -> (a :~: b) -> Bool Source # (/=) :: (a :~: b) -> (a :~: b) -> Bool Source #
Ord (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods compare :: (a :~: b) -> (a :~: b) -> Ordering Source # (<) :: (a :~: b) -> (a :~: b) -> Bool Source # (<=) :: (a :~: b) -> (a :~: b) -> Bool Source # (>) :: (a :~: b) -> (a :~: b) -> Bool Source # (>=) :: (a :~: b) -> (a :~: b) -> Bool Source # max :: (a :~: b) -> (a :~: b) -> a :~: b Source # min :: (a :~: b) -> (a :~: b) -> a :~: b Source #
a ~ b => Read (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods readsPrec :: Int -> ReadS (a :~: b) Source # readList :: ReadS [a :~: b] Source # readPrec :: ReadPrec (a :~: b) Source # readListPrec :: ReadPrec [a :~: b] Source #
Show (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~: b) -> ShowS Source # show :: (a :~: b) -> String Source # showList :: [a :~: b] -> ShowS Source #
NFData (a :~: b)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a :~: b) -> () Source #

type family (a :: k) == (b :: k) :: Bool where ... infix 4 Source #

A type family to compute Boolean equality.

Equations

(f a :: k2) == (g b :: k2) = (f == g) && (a == b)
(a :: k) == (a :: k) = ' True
(_1 :: k) == (_2 :: k) = ' False

data WordPtr Source #

An unsigned integral type that can be losslessly converted to and from Ptr . This type is also compatible with the C99 type uintptr_t , and can be marshalled to and from that type safely.

Instances

Instances details

Bounded WordPtr
Instance details Defined in Foreign.Ptr Methods minBound :: WordPtr Source # maxBound :: WordPtr Source #
Enum WordPtr
Instance details Defined in Foreign.Ptr Methods succ :: WordPtr -> WordPtr Source # pred :: WordPtr -> WordPtr Source # toEnum :: Int -> WordPtr Source # fromEnum :: WordPtr -> Int Source # enumFrom :: WordPtr -> [ WordPtr ] Source # enumFromThen :: WordPtr -> WordPtr -> [ WordPtr ] Source # enumFromTo :: WordPtr -> WordPtr -> [ WordPtr ] Source # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [ WordPtr ] Source #
Eq WordPtr
Instance details Defined in Foreign.Ptr Methods (==) :: WordPtr -> WordPtr -> Bool Source # (/=) :: WordPtr -> WordPtr -> Bool Source #
Integral WordPtr
Instance details Defined in Foreign.Ptr Methods quot :: WordPtr -> WordPtr -> WordPtr Source # rem :: WordPtr -> WordPtr -> WordPtr Source # div :: WordPtr -> WordPtr -> WordPtr Source # mod :: WordPtr -> WordPtr -> WordPtr Source # quotRem :: WordPtr -> WordPtr -> ( WordPtr , WordPtr ) Source # divMod :: WordPtr -> WordPtr -> ( WordPtr , WordPtr ) Source # toInteger :: WordPtr -> Integer Source #
Num WordPtr
Instance details Defined in Foreign.Ptr Methods (+) :: WordPtr -> WordPtr -> WordPtr Source # (-) :: WordPtr -> WordPtr -> WordPtr Source # (*) :: WordPtr -> WordPtr -> WordPtr Source # negate :: WordPtr -> WordPtr Source # abs :: WordPtr -> WordPtr Source # signum :: WordPtr -> WordPtr Source # fromInteger :: Integer -> WordPtr Source #
Ord WordPtr
Instance details Defined in Foreign.Ptr Methods compare :: WordPtr -> WordPtr -> Ordering Source # (<) :: WordPtr -> WordPtr -> Bool Source # (<=) :: WordPtr -> WordPtr -> Bool Source # (>) :: WordPtr -> WordPtr -> Bool Source # (>=) :: WordPtr -> WordPtr -> Bool Source # max :: WordPtr -> WordPtr -> WordPtr Source # min :: WordPtr -> WordPtr -> WordPtr Source #
Read WordPtr
Instance details Defined in Foreign.Ptr Methods readsPrec :: Int -> ReadS WordPtr Source # readList :: ReadS [ WordPtr ] Source # readPrec :: ReadPrec WordPtr Source # readListPrec :: ReadPrec [ WordPtr ] Source #
Real WordPtr
Instance details Defined in Foreign.Ptr Methods toRational :: WordPtr -> Rational Source #
Show WordPtr
Instance details Defined in Foreign.Ptr Methods showsPrec :: Int -> WordPtr -> ShowS Source # show :: WordPtr -> String Source # showList :: [ WordPtr ] -> ShowS Source #
Hashable WordPtr
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WordPtr -> Int Source # hash :: WordPtr -> Int Source #
Storable WordPtr
Instance details Defined in Foreign.Ptr Methods sizeOf :: WordPtr -> Int Source # alignment :: WordPtr -> Int Source # peekElemOff :: Ptr WordPtr -> Int -> IO WordPtr Source # pokeElemOff :: Ptr WordPtr -> Int -> WordPtr -> IO () Source # peekByteOff :: Ptr b -> Int -> IO WordPtr Source # pokeByteOff :: Ptr b -> Int -> WordPtr -> IO () Source # peek :: Ptr WordPtr -> IO WordPtr Source # poke :: Ptr WordPtr -> WordPtr -> IO () Source #
Bits WordPtr
Instance details Defined in Foreign.Ptr Methods (.&.) :: WordPtr -> WordPtr -> WordPtr Source # (.\|.) :: WordPtr -> WordPtr -> WordPtr Source # xor :: WordPtr -> WordPtr -> WordPtr Source # complement :: WordPtr -> WordPtr Source # shift :: WordPtr -> Int -> WordPtr Source # rotate :: WordPtr -> Int -> WordPtr Source # zeroBits :: WordPtr Source # bit :: Int -> WordPtr Source # setBit :: WordPtr -> Int -> WordPtr Source # clearBit :: WordPtr -> Int -> WordPtr Source # complementBit :: WordPtr -> Int -> WordPtr Source # testBit :: WordPtr -> Int -> Bool Source # bitSizeMaybe :: WordPtr -> Maybe Int Source # bitSize :: WordPtr -> Int Source # isSigned :: WordPtr -> Bool Source # shiftL :: WordPtr -> Int -> WordPtr Source # unsafeShiftL :: WordPtr -> Int -> WordPtr Source # shiftR :: WordPtr -> Int -> WordPtr Source # unsafeShiftR :: WordPtr -> Int -> WordPtr Source # rotateL :: WordPtr -> Int -> WordPtr Source # rotateR :: WordPtr -> Int -> WordPtr Source # popCount :: WordPtr -> Int Source #
FiniteBits WordPtr
Instance details Defined in Foreign.Ptr Methods finiteBitSize :: WordPtr -> Int Source # countLeadingZeros :: WordPtr -> Int Source # countTrailingZeros :: WordPtr -> Int Source #
Buildable WordPtr
Instance details Defined in Formatting.Buildable Methods build :: WordPtr -> Builder Source #
Prim WordPtr	Since: primitive-0.7.1.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: WordPtr -> Int# Source # alignment# :: WordPtr -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> WordPtr Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, WordPtr #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> WordPtr -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> WordPtr Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, WordPtr #) Source # writeOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> WordPtr -> State# s -> State# s Source #

data IntPtr Source #

A signed integral type that can be losslessly converted to and from Ptr . This type is also compatible with the C99 type intptr_t , and can be marshalled to and from that type safely.

Instances

Instances details

Bounded IntPtr
Instance details Defined in Foreign.Ptr Methods minBound :: IntPtr Source # maxBound :: IntPtr Source #
Enum IntPtr
Instance details Defined in Foreign.Ptr Methods succ :: IntPtr -> IntPtr Source # pred :: IntPtr -> IntPtr Source # toEnum :: Int -> IntPtr Source # fromEnum :: IntPtr -> Int Source # enumFrom :: IntPtr -> [ IntPtr ] Source # enumFromThen :: IntPtr -> IntPtr -> [ IntPtr ] Source # enumFromTo :: IntPtr -> IntPtr -> [ IntPtr ] Source # enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [ IntPtr ] Source #
Eq IntPtr
Instance details Defined in Foreign.Ptr Methods (==) :: IntPtr -> IntPtr -> Bool Source # (/=) :: IntPtr -> IntPtr -> Bool Source #
Integral IntPtr
Instance details Defined in Foreign.Ptr Methods quot :: IntPtr -> IntPtr -> IntPtr Source # rem :: IntPtr -> IntPtr -> IntPtr Source # div :: IntPtr -> IntPtr -> IntPtr Source # mod :: IntPtr -> IntPtr -> IntPtr Source # quotRem :: IntPtr -> IntPtr -> ( IntPtr , IntPtr ) Source # divMod :: IntPtr -> IntPtr -> ( IntPtr , IntPtr ) Source # toInteger :: IntPtr -> Integer Source #
Num IntPtr
Instance details Defined in Foreign.Ptr Methods (+) :: IntPtr -> IntPtr -> IntPtr Source # (-) :: IntPtr -> IntPtr -> IntPtr Source # (*) :: IntPtr -> IntPtr -> IntPtr Source # negate :: IntPtr -> IntPtr Source # abs :: IntPtr -> IntPtr Source # signum :: IntPtr -> IntPtr Source # fromInteger :: Integer -> IntPtr Source #
Ord IntPtr
Instance details Defined in Foreign.Ptr Methods compare :: IntPtr -> IntPtr -> Ordering Source # (<) :: IntPtr -> IntPtr -> Bool Source # (<=) :: IntPtr -> IntPtr -> Bool Source # (>) :: IntPtr -> IntPtr -> Bool Source # (>=) :: IntPtr -> IntPtr -> Bool Source # max :: IntPtr -> IntPtr -> IntPtr Source # min :: IntPtr -> IntPtr -> IntPtr Source #
Read IntPtr
Instance details Defined in Foreign.Ptr Methods readsPrec :: Int -> ReadS IntPtr Source # readList :: ReadS [ IntPtr ] Source # readPrec :: ReadPrec IntPtr Source # readListPrec :: ReadPrec [ IntPtr ] Source #
Real IntPtr
Instance details Defined in Foreign.Ptr Methods toRational :: IntPtr -> Rational Source #
Show IntPtr
Instance details Defined in Foreign.Ptr Methods showsPrec :: Int -> IntPtr -> ShowS Source # show :: IntPtr -> String Source # showList :: [ IntPtr ] -> ShowS Source #
Hashable IntPtr
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntPtr -> Int Source # hash :: IntPtr -> Int Source #
Storable IntPtr
Instance details Defined in Foreign.Ptr Methods sizeOf :: IntPtr -> Int Source # alignment :: IntPtr -> Int Source # peekElemOff :: Ptr IntPtr -> Int -> IO IntPtr Source # pokeElemOff :: Ptr IntPtr -> Int -> IntPtr -> IO () Source # peekByteOff :: Ptr b -> Int -> IO IntPtr Source # pokeByteOff :: Ptr b -> Int -> IntPtr -> IO () Source # peek :: Ptr IntPtr -> IO IntPtr Source # poke :: Ptr IntPtr -> IntPtr -> IO () Source #
Bits IntPtr
Instance details Defined in Foreign.Ptr Methods (.&.) :: IntPtr -> IntPtr -> IntPtr Source # (.\|.) :: IntPtr -> IntPtr -> IntPtr Source # xor :: IntPtr -> IntPtr -> IntPtr Source # complement :: IntPtr -> IntPtr Source # shift :: IntPtr -> Int -> IntPtr Source # rotate :: IntPtr -> Int -> IntPtr Source # zeroBits :: IntPtr Source # bit :: Int -> IntPtr Source # setBit :: IntPtr -> Int -> IntPtr Source # clearBit :: IntPtr -> Int -> IntPtr Source # complementBit :: IntPtr -> Int -> IntPtr Source # testBit :: IntPtr -> Int -> Bool Source # bitSizeMaybe :: IntPtr -> Maybe Int Source # bitSize :: IntPtr -> Int Source # isSigned :: IntPtr -> Bool Source # shiftL :: IntPtr -> Int -> IntPtr Source # unsafeShiftL :: IntPtr -> Int -> IntPtr Source # shiftR :: IntPtr -> Int -> IntPtr Source # unsafeShiftR :: IntPtr -> Int -> IntPtr Source # rotateL :: IntPtr -> Int -> IntPtr Source # rotateR :: IntPtr -> Int -> IntPtr Source # popCount :: IntPtr -> Int Source #
FiniteBits IntPtr
Instance details Defined in Foreign.Ptr Methods finiteBitSize :: IntPtr -> Int Source # countLeadingZeros :: IntPtr -> Int Source # countTrailingZeros :: IntPtr -> Int Source #
Buildable IntPtr
Instance details Defined in Formatting.Buildable Methods build :: IntPtr -> Builder Source #
Prim IntPtr	Since: primitive-0.7.1.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: IntPtr -> Int# Source # alignment# :: IntPtr -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> IntPtr Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, IntPtr #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> IntPtr -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> IntPtr Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, IntPtr #) Source # writeOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> IntPtr -> State# s -> State# s Source #

data IOMode Source #

See openFile

Constructors

ReadMode
WriteMode
AppendMode
ReadWriteMode

Instances

Instances details

Enum IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods succ :: IOMode -> IOMode Source # pred :: IOMode -> IOMode Source # toEnum :: Int -> IOMode Source # fromEnum :: IOMode -> Int Source # enumFrom :: IOMode -> [ IOMode ] Source # enumFromThen :: IOMode -> IOMode -> [ IOMode ] Source # enumFromTo :: IOMode -> IOMode -> [ IOMode ] Source # enumFromThenTo :: IOMode -> IOMode -> IOMode -> [ IOMode ] Source #
Eq IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods (==) :: IOMode -> IOMode -> Bool Source # (/=) :: IOMode -> IOMode -> Bool Source #
Ord IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods compare :: IOMode -> IOMode -> Ordering Source # (<) :: IOMode -> IOMode -> Bool Source # (<=) :: IOMode -> IOMode -> Bool Source # (>) :: IOMode -> IOMode -> Bool Source # (>=) :: IOMode -> IOMode -> Bool Source # max :: IOMode -> IOMode -> IOMode Source # min :: IOMode -> IOMode -> IOMode Source #
Read IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods readsPrec :: Int -> ReadS IOMode Source # readList :: ReadS [ IOMode ] Source # readPrec :: ReadPrec IOMode Source # readListPrec :: ReadPrec [ IOMode ] Source #
Show IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods showsPrec :: Int -> IOMode -> ShowS Source # show :: IOMode -> String Source # showList :: [ IOMode ] -> ShowS Source #
Ix IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods range :: ( IOMode , IOMode ) -> [ IOMode ] Source # index :: ( IOMode , IOMode ) -> IOMode -> Int Source # unsafeIndex :: ( IOMode , IOMode ) -> IOMode -> Int Source # inRange :: ( IOMode , IOMode ) -> IOMode -> Bool Source # rangeSize :: ( IOMode , IOMode ) -> Int Source # unsafeRangeSize :: ( IOMode , IOMode ) -> Int Source #

class Storable a Source #

The member functions of this class facilitate writing values of primitive types to raw memory (which may have been allocated with the above mentioned routines) and reading values from blocks of raw memory. The class, furthermore, includes support for computing the storage requirements and alignment restrictions of storable types.

Memory addresses are represented as values of type Ptr a , for some a which is an instance of class Storable . The type argument to Ptr helps provide some valuable type safety in FFI code (you can't mix pointers of different types without an explicit cast), while helping the Haskell type system figure out which marshalling method is needed for a given pointer.

All marshalling between Haskell and a foreign language ultimately boils down to translating Haskell data structures into the binary representation of a corresponding data structure of the foreign language and vice versa. To code this marshalling in Haskell, it is necessary to manipulate primitive data types stored in unstructured memory blocks. The class Storable facilitates this manipulation on all types for which it is instantiated, which are the standard basic types of Haskell, the fixed size Int types ( Int8 , Int16 , Int32 , Int64 ), the fixed size Word types ( Word8 , Word16 , Word32 , Word64 ), StablePtr , all types from Foreign.C.Types , as well as Ptr .

Minimal complete definition

sizeOf , alignment , ( peek | peekElemOff | peekByteOff ), ( poke | pokeElemOff | pokeByteOff )

Instances

Instances details

Storable Bool	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Bool -> Int Source # alignment :: Bool -> Int Source # peekElemOff :: Ptr Bool -> Int -> IO Bool Source # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Bool Source # pokeByteOff :: Ptr b -> Int -> Bool -> IO () Source # peek :: Ptr Bool -> IO Bool Source # poke :: Ptr Bool -> Bool -> IO () Source #
Storable Char	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Char -> Int Source # alignment :: Char -> Int Source # peekElemOff :: Ptr Char -> Int -> IO Char Source # pokeElemOff :: Ptr Char -> Int -> Char -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Char Source # pokeByteOff :: Ptr b -> Int -> Char -> IO () Source # peek :: Ptr Char -> IO Char Source # poke :: Ptr Char -> Char -> IO () Source #
Storable Double	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Double -> Int Source # alignment :: Double -> Int Source # peekElemOff :: Ptr Double -> Int -> IO Double Source # pokeElemOff :: Ptr Double -> Int -> Double -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Double Source # pokeByteOff :: Ptr b -> Int -> Double -> IO () Source # peek :: Ptr Double -> IO Double Source # poke :: Ptr Double -> Double -> IO () Source #
Storable Float	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Float -> Int Source # alignment :: Float -> Int Source # peekElemOff :: Ptr Float -> Int -> IO Float Source # pokeElemOff :: Ptr Float -> Int -> Float -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Float Source # pokeByteOff :: Ptr b -> Int -> Float -> IO () Source # peek :: Ptr Float -> IO Float Source # poke :: Ptr Float -> Float -> IO () Source #
Storable Int	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int -> Int Source # alignment :: Int -> Int Source # peekElemOff :: Ptr Int -> Int -> IO Int Source # pokeElemOff :: Ptr Int -> Int -> Int -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int Source # pokeByteOff :: Ptr b -> Int -> Int -> IO () Source # peek :: Ptr Int -> IO Int Source # poke :: Ptr Int -> Int -> IO () Source #
Storable Int8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int8 -> Int Source # alignment :: Int8 -> Int Source # peekElemOff :: Ptr Int8 -> Int -> IO Int8 Source # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int8 Source # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () Source # peek :: Ptr Int8 -> IO Int8 Source # poke :: Ptr Int8 -> Int8 -> IO () Source #
Storable Int16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int16 -> Int Source # alignment :: Int16 -> Int Source # peekElemOff :: Ptr Int16 -> Int -> IO Int16 Source # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int16 Source # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () Source # peek :: Ptr Int16 -> IO Int16 Source # poke :: Ptr Int16 -> Int16 -> IO () Source #
Storable Int32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int32 -> Int Source # alignment :: Int32 -> Int Source # peekElemOff :: Ptr Int32 -> Int -> IO Int32 Source # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int32 Source # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () Source # peek :: Ptr Int32 -> IO Int32 Source # poke :: Ptr Int32 -> Int32 -> IO () Source #
Storable Int64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int64 -> Int Source # alignment :: Int64 -> Int Source # peekElemOff :: Ptr Int64 -> Int -> IO Int64 Source # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int64 Source # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () Source # peek :: Ptr Int64 -> IO Int64 Source # poke :: Ptr Int64 -> Int64 -> IO () Source #
Storable Word	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word -> Int Source # alignment :: Word -> Int Source # peekElemOff :: Ptr Word -> Int -> IO Word Source # pokeElemOff :: Ptr Word -> Int -> Word -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word Source # pokeByteOff :: Ptr b -> Int -> Word -> IO () Source # peek :: Ptr Word -> IO Word Source # poke :: Ptr Word -> Word -> IO () Source #
Storable Word8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word8 -> Int Source # alignment :: Word8 -> Int Source # peekElemOff :: Ptr Word8 -> Int -> IO Word8 Source # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word8 Source # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () Source # peek :: Ptr Word8 -> IO Word8 Source # poke :: Ptr Word8 -> Word8 -> IO () Source #
Storable Word16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word16 -> Int Source # alignment :: Word16 -> Int Source # peekElemOff :: Ptr Word16 -> Int -> IO Word16 Source # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word16 Source # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () Source # peek :: Ptr Word16 -> IO Word16 Source # poke :: Ptr Word16 -> Word16 -> IO () Source #
Storable Word32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word32 -> Int Source # alignment :: Word32 -> Int Source # peekElemOff :: Ptr Word32 -> Int -> IO Word32 Source # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word32 Source # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () Source # peek :: Ptr Word32 -> IO Word32 Source # poke :: Ptr Word32 -> Word32 -> IO () Source #
Storable Word64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word64 -> Int Source # alignment :: Word64 -> Int Source # peekElemOff :: Ptr Word64 -> Int -> IO Word64 Source # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word64 Source # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () Source # peek :: Ptr Word64 -> IO Word64 Source # poke :: Ptr Word64 -> Word64 -> IO () Source #
Storable ()	Since: base-4.9.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: () -> Int Source # alignment :: () -> Int Source # peekElemOff :: Ptr () -> Int -> IO () Source # pokeElemOff :: Ptr () -> Int -> () -> IO () Source # peekByteOff :: Ptr b -> Int -> IO () Source # pokeByteOff :: Ptr b -> Int -> () -> IO () Source # peek :: Ptr () -> IO () Source # poke :: Ptr () -> () -> IO () Source #
Storable CDev
Instance details Defined in System.Posix.Types Methods sizeOf :: CDev -> Int Source # alignment :: CDev -> Int Source # peekElemOff :: Ptr CDev -> Int -> IO CDev Source # pokeElemOff :: Ptr CDev -> Int -> CDev -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CDev Source # pokeByteOff :: Ptr b -> Int -> CDev -> IO () Source # peek :: Ptr CDev -> IO CDev Source # poke :: Ptr CDev -> CDev -> IO () Source #
Storable CIno
Instance details Defined in System.Posix.Types Methods sizeOf :: CIno -> Int Source # alignment :: CIno -> Int Source # peekElemOff :: Ptr CIno -> Int -> IO CIno Source # pokeElemOff :: Ptr CIno -> Int -> CIno -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CIno Source # pokeByteOff :: Ptr b -> Int -> CIno -> IO () Source # peek :: Ptr CIno -> IO CIno Source # poke :: Ptr CIno -> CIno -> IO () Source #
Storable CMode
Instance details Defined in System.Posix.Types Methods sizeOf :: CMode -> Int Source # alignment :: CMode -> Int Source # peekElemOff :: Ptr CMode -> Int -> IO CMode Source # pokeElemOff :: Ptr CMode -> Int -> CMode -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CMode Source # pokeByteOff :: Ptr b -> Int -> CMode -> IO () Source # peek :: Ptr CMode -> IO CMode Source # poke :: Ptr CMode -> CMode -> IO () Source #
Storable COff
Instance details Defined in System.Posix.Types Methods sizeOf :: COff -> Int Source # alignment :: COff -> Int Source # peekElemOff :: Ptr COff -> Int -> IO COff Source # pokeElemOff :: Ptr COff -> Int -> COff -> IO () Source # peekByteOff :: Ptr b -> Int -> IO COff Source # pokeByteOff :: Ptr b -> Int -> COff -> IO () Source # peek :: Ptr COff -> IO COff Source # poke :: Ptr COff -> COff -> IO () Source #
Storable CPid
Instance details Defined in System.Posix.Types Methods sizeOf :: CPid -> Int Source # alignment :: CPid -> Int Source # peekElemOff :: Ptr CPid -> Int -> IO CPid Source # pokeElemOff :: Ptr CPid -> Int -> CPid -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CPid Source # pokeByteOff :: Ptr b -> Int -> CPid -> IO () Source # peek :: Ptr CPid -> IO CPid Source # poke :: Ptr CPid -> CPid -> IO () Source #
Storable CSsize
Instance details Defined in System.Posix.Types Methods sizeOf :: CSsize -> Int Source # alignment :: CSsize -> Int Source # peekElemOff :: Ptr CSsize -> Int -> IO CSsize Source # pokeElemOff :: Ptr CSsize -> Int -> CSsize -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CSsize Source # pokeByteOff :: Ptr b -> Int -> CSsize -> IO () Source # peek :: Ptr CSsize -> IO CSsize Source # poke :: Ptr CSsize -> CSsize -> IO () Source #
Storable CGid
Instance details Defined in System.Posix.Types Methods sizeOf :: CGid -> Int Source # alignment :: CGid -> Int Source # peekElemOff :: Ptr CGid -> Int -> IO CGid Source # pokeElemOff :: Ptr CGid -> Int -> CGid -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CGid Source # pokeByteOff :: Ptr b -> Int -> CGid -> IO () Source # peek :: Ptr CGid -> IO CGid Source # poke :: Ptr CGid -> CGid -> IO () Source #
Storable CNlink
Instance details Defined in System.Posix.Types Methods sizeOf :: CNlink -> Int Source # alignment :: CNlink -> Int Source # peekElemOff :: Ptr CNlink -> Int -> IO CNlink Source # pokeElemOff :: Ptr CNlink -> Int -> CNlink -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CNlink Source # pokeByteOff :: Ptr b -> Int -> CNlink -> IO () Source # peek :: Ptr CNlink -> IO CNlink Source # poke :: Ptr CNlink -> CNlink -> IO () Source #
Storable CUid
Instance details Defined in System.Posix.Types Methods sizeOf :: CUid -> Int Source # alignment :: CUid -> Int Source # peekElemOff :: Ptr CUid -> Int -> IO CUid Source # pokeElemOff :: Ptr CUid -> Int -> CUid -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CUid Source # pokeByteOff :: Ptr b -> Int -> CUid -> IO () Source # peek :: Ptr CUid -> IO CUid Source # poke :: Ptr CUid -> CUid -> IO () Source #
Storable CCc
Instance details Defined in System.Posix.Types Methods sizeOf :: CCc -> Int Source # alignment :: CCc -> Int Source # peekElemOff :: Ptr CCc -> Int -> IO CCc Source # pokeElemOff :: Ptr CCc -> Int -> CCc -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CCc Source # pokeByteOff :: Ptr b -> Int -> CCc -> IO () Source # peek :: Ptr CCc -> IO CCc Source # poke :: Ptr CCc -> CCc -> IO () Source #
Storable CSpeed
Instance details Defined in System.Posix.Types Methods sizeOf :: CSpeed -> Int Source # alignment :: CSpeed -> Int Source # peekElemOff :: Ptr CSpeed -> Int -> IO CSpeed Source # pokeElemOff :: Ptr CSpeed -> Int -> CSpeed -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CSpeed Source # pokeByteOff :: Ptr b -> Int -> CSpeed -> IO () Source # peek :: Ptr CSpeed -> IO CSpeed Source # poke :: Ptr CSpeed -> CSpeed -> IO () Source #
Storable CTcflag
Instance details Defined in System.Posix.Types Methods sizeOf :: CTcflag -> Int Source # alignment :: CTcflag -> Int Source # peekElemOff :: Ptr CTcflag -> Int -> IO CTcflag Source # pokeElemOff :: Ptr CTcflag -> Int -> CTcflag -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CTcflag Source # pokeByteOff :: Ptr b -> Int -> CTcflag -> IO () Source # peek :: Ptr CTcflag -> IO CTcflag Source # poke :: Ptr CTcflag -> CTcflag -> IO () Source #
Storable CRLim
Instance details Defined in System.Posix.Types Methods sizeOf :: CRLim -> Int Source # alignment :: CRLim -> Int Source # peekElemOff :: Ptr CRLim -> Int -> IO CRLim Source # pokeElemOff :: Ptr CRLim -> Int -> CRLim -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CRLim Source # pokeByteOff :: Ptr b -> Int -> CRLim -> IO () Source # peek :: Ptr CRLim -> IO CRLim Source # poke :: Ptr CRLim -> CRLim -> IO () Source #
Storable CBlkSize
Instance details Defined in System.Posix.Types Methods sizeOf :: CBlkSize -> Int Source # alignment :: CBlkSize -> Int Source # peekElemOff :: Ptr CBlkSize -> Int -> IO CBlkSize Source # pokeElemOff :: Ptr CBlkSize -> Int -> CBlkSize -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CBlkSize Source # pokeByteOff :: Ptr b -> Int -> CBlkSize -> IO () Source # peek :: Ptr CBlkSize -> IO CBlkSize Source # poke :: Ptr CBlkSize -> CBlkSize -> IO () Source #
Storable CBlkCnt
Instance details Defined in System.Posix.Types Methods sizeOf :: CBlkCnt -> Int Source # alignment :: CBlkCnt -> Int Source # peekElemOff :: Ptr CBlkCnt -> Int -> IO CBlkCnt Source # pokeElemOff :: Ptr CBlkCnt -> Int -> CBlkCnt -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CBlkCnt Source # pokeByteOff :: Ptr b -> Int -> CBlkCnt -> IO () Source # peek :: Ptr CBlkCnt -> IO CBlkCnt Source # poke :: Ptr CBlkCnt -> CBlkCnt -> IO () Source #
Storable CClockId
Instance details Defined in System.Posix.Types Methods sizeOf :: CClockId -> Int Source # alignment :: CClockId -> Int Source # peekElemOff :: Ptr CClockId -> Int -> IO CClockId Source # pokeElemOff :: Ptr CClockId -> Int -> CClockId -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CClockId Source # pokeByteOff :: Ptr b -> Int -> CClockId -> IO () Source # peek :: Ptr CClockId -> IO CClockId Source # poke :: Ptr CClockId -> CClockId -> IO () Source #
Storable CFsBlkCnt
Instance details Defined in System.Posix.Types Methods sizeOf :: CFsBlkCnt -> Int Source # alignment :: CFsBlkCnt -> Int Source # peekElemOff :: Ptr CFsBlkCnt -> Int -> IO CFsBlkCnt Source # pokeElemOff :: Ptr CFsBlkCnt -> Int -> CFsBlkCnt -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CFsBlkCnt Source # pokeByteOff :: Ptr b -> Int -> CFsBlkCnt -> IO () Source # peek :: Ptr CFsBlkCnt -> IO CFsBlkCnt Source # poke :: Ptr CFsBlkCnt -> CFsBlkCnt -> IO () Source #
Storable CFsFilCnt
Instance details Defined in System.Posix.Types Methods sizeOf :: CFsFilCnt -> Int Source # alignment :: CFsFilCnt -> Int Source # peekElemOff :: Ptr CFsFilCnt -> Int -> IO CFsFilCnt Source # pokeElemOff :: Ptr CFsFilCnt -> Int -> CFsFilCnt -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CFsFilCnt Source # pokeByteOff :: Ptr b -> Int -> CFsFilCnt -> IO () Source # peek :: Ptr CFsFilCnt -> IO CFsFilCnt Source # poke :: Ptr CFsFilCnt -> CFsFilCnt -> IO () Source #
Storable CId
Instance details Defined in System.Posix.Types Methods sizeOf :: CId -> Int Source # alignment :: CId -> Int Source # peekElemOff :: Ptr CId -> Int -> IO CId Source # pokeElemOff :: Ptr CId -> Int -> CId -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CId Source # pokeByteOff :: Ptr b -> Int -> CId -> IO () Source # peek :: Ptr CId -> IO CId Source # poke :: Ptr CId -> CId -> IO () Source #
Storable CKey
Instance details Defined in System.Posix.Types Methods sizeOf :: CKey -> Int Source # alignment :: CKey -> Int Source # peekElemOff :: Ptr CKey -> Int -> IO CKey Source # pokeElemOff :: Ptr CKey -> Int -> CKey -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CKey Source # pokeByteOff :: Ptr b -> Int -> CKey -> IO () Source # peek :: Ptr CKey -> IO CKey Source # poke :: Ptr CKey -> CKey -> IO () Source #
Storable CSocklen
Instance details Defined in System.Posix.Types Methods sizeOf :: CSocklen -> Int Source # alignment :: CSocklen -> Int Source # peekElemOff :: Ptr CSocklen -> Int -> IO CSocklen Source # pokeElemOff :: Ptr CSocklen -> Int -> CSocklen -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CSocklen Source # pokeByteOff :: Ptr b -> Int -> CSocklen -> IO () Source # peek :: Ptr CSocklen -> IO CSocklen Source # poke :: Ptr CSocklen -> CSocklen -> IO () Source #
Storable CNfds
Instance details Defined in System.Posix.Types Methods sizeOf :: CNfds -> Int Source # alignment :: CNfds -> Int Source # peekElemOff :: Ptr CNfds -> Int -> IO CNfds Source # pokeElemOff :: Ptr CNfds -> Int -> CNfds -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CNfds Source # pokeByteOff :: Ptr b -> Int -> CNfds -> IO () Source # peek :: Ptr CNfds -> IO CNfds Source # poke :: Ptr CNfds -> CNfds -> IO () Source #
Storable Fd
Instance details Defined in System.Posix.Types Methods sizeOf :: Fd -> Int Source # alignment :: Fd -> Int Source # peekElemOff :: Ptr Fd -> Int -> IO Fd Source # pokeElemOff :: Ptr Fd -> Int -> Fd -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Fd Source # pokeByteOff :: Ptr b -> Int -> Fd -> IO () Source # peek :: Ptr Fd -> IO Fd Source # poke :: Ptr Fd -> Fd -> IO () Source #
Storable CChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CChar -> Int Source # alignment :: CChar -> Int Source # peekElemOff :: Ptr CChar -> Int -> IO CChar Source # pokeElemOff :: Ptr CChar -> Int -> CChar -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CChar Source # pokeByteOff :: Ptr b -> Int -> CChar -> IO () Source # peek :: Ptr CChar -> IO CChar Source # poke :: Ptr CChar -> CChar -> IO () Source #
Storable CSChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSChar -> Int Source # alignment :: CSChar -> Int Source # peekElemOff :: Ptr CSChar -> Int -> IO CSChar Source # pokeElemOff :: Ptr CSChar -> Int -> CSChar -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CSChar Source # pokeByteOff :: Ptr b -> Int -> CSChar -> IO () Source # peek :: Ptr CSChar -> IO CSChar Source # poke :: Ptr CSChar -> CSChar -> IO () Source #
Storable CUChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUChar -> Int Source # alignment :: CUChar -> Int Source # peekElemOff :: Ptr CUChar -> Int -> IO CUChar Source # pokeElemOff :: Ptr CUChar -> Int -> CUChar -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CUChar Source # pokeByteOff :: Ptr b -> Int -> CUChar -> IO () Source # peek :: Ptr CUChar -> IO CUChar Source # poke :: Ptr CUChar -> CUChar -> IO () Source #
Storable CShort
Instance details Defined in Foreign.C.Types Methods sizeOf :: CShort -> Int Source # alignment :: CShort -> Int Source # peekElemOff :: Ptr CShort -> Int -> IO CShort Source # pokeElemOff :: Ptr CShort -> Int -> CShort -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CShort Source # pokeByteOff :: Ptr b -> Int -> CShort -> IO () Source # peek :: Ptr CShort -> IO CShort Source # poke :: Ptr CShort -> CShort -> IO () Source #
Storable CUShort
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUShort -> Int Source # alignment :: CUShort -> Int Source # peekElemOff :: Ptr CUShort -> Int -> IO CUShort Source # pokeElemOff :: Ptr CUShort -> Int -> CUShort -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CUShort Source # pokeByteOff :: Ptr b -> Int -> CUShort -> IO () Source # peek :: Ptr CUShort -> IO CUShort Source # poke :: Ptr CUShort -> CUShort -> IO () Source #
Storable CInt
Instance details Defined in Foreign.C.Types Methods sizeOf :: CInt -> Int Source # alignment :: CInt -> Int Source # peekElemOff :: Ptr CInt -> Int -> IO CInt Source # pokeElemOff :: Ptr CInt -> Int -> CInt -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CInt Source # pokeByteOff :: Ptr b -> Int -> CInt -> IO () Source # peek :: Ptr CInt -> IO CInt Source # poke :: Ptr CInt -> CInt -> IO () Source #
Storable CUInt
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUInt -> Int Source # alignment :: CUInt -> Int Source # peekElemOff :: Ptr CUInt -> Int -> IO CUInt Source # pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CUInt Source # pokeByteOff :: Ptr b -> Int -> CUInt -> IO () Source # peek :: Ptr CUInt -> IO CUInt Source # poke :: Ptr CUInt -> CUInt -> IO () Source #
Storable CLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CLong -> Int Source # alignment :: CLong -> Int Source # peekElemOff :: Ptr CLong -> Int -> IO CLong Source # pokeElemOff :: Ptr CLong -> Int -> CLong -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CLong Source # pokeByteOff :: Ptr b -> Int -> CLong -> IO () Source # peek :: Ptr CLong -> IO CLong Source # poke :: Ptr CLong -> CLong -> IO () Source #
Storable CULong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CULong -> Int Source # alignment :: CULong -> Int Source # peekElemOff :: Ptr CULong -> Int -> IO CULong Source # pokeElemOff :: Ptr CULong -> Int -> CULong -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CULong Source # pokeByteOff :: Ptr b -> Int -> CULong -> IO () Source # peek :: Ptr CULong -> IO CULong Source # poke :: Ptr CULong -> CULong -> IO () Source #
Storable CLLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CLLong -> Int Source # alignment :: CLLong -> Int Source # peekElemOff :: Ptr CLLong -> Int -> IO CLLong Source # pokeElemOff :: Ptr CLLong -> Int -> CLLong -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CLLong Source # pokeByteOff :: Ptr b -> Int -> CLLong -> IO () Source # peek :: Ptr CLLong -> IO CLLong Source # poke :: Ptr CLLong -> CLLong -> IO () Source #
Storable CULLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CULLong -> Int Source # alignment :: CULLong -> Int Source # peekElemOff :: Ptr CULLong -> Int -> IO CULLong Source # pokeElemOff :: Ptr CULLong -> Int -> CULLong -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CULLong Source # pokeByteOff :: Ptr b -> Int -> CULLong -> IO () Source # peek :: Ptr CULLong -> IO CULLong Source # poke :: Ptr CULLong -> CULLong -> IO () Source #
Storable CBool
Instance details Defined in Foreign.C.Types Methods sizeOf :: CBool -> Int Source # alignment :: CBool -> Int Source # peekElemOff :: Ptr CBool -> Int -> IO CBool Source # pokeElemOff :: Ptr CBool -> Int -> CBool -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CBool Source # pokeByteOff :: Ptr b -> Int -> CBool -> IO () Source # peek :: Ptr CBool -> IO CBool Source # poke :: Ptr CBool -> CBool -> IO () Source #
Storable CFloat
Instance details Defined in Foreign.C.Types Methods sizeOf :: CFloat -> Int Source # alignment :: CFloat -> Int Source # peekElemOff :: Ptr CFloat -> Int -> IO CFloat Source # pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CFloat Source # pokeByteOff :: Ptr b -> Int -> CFloat -> IO () Source # peek :: Ptr CFloat -> IO CFloat Source # poke :: Ptr CFloat -> CFloat -> IO () Source #
Storable CDouble
Instance details Defined in Foreign.C.Types Methods sizeOf :: CDouble -> Int Source # alignment :: CDouble -> Int Source # peekElemOff :: Ptr CDouble -> Int -> IO CDouble Source # pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CDouble Source # pokeByteOff :: Ptr b -> Int -> CDouble -> IO () Source # peek :: Ptr CDouble -> IO CDouble Source # poke :: Ptr CDouble -> CDouble -> IO () Source #
Storable CPtrdiff
Instance details Defined in Foreign.C.Types Methods sizeOf :: CPtrdiff -> Int Source # alignment :: CPtrdiff -> Int Source # peekElemOff :: Ptr CPtrdiff -> Int -> IO CPtrdiff Source # pokeElemOff :: Ptr CPtrdiff -> Int -> CPtrdiff -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CPtrdiff Source # pokeByteOff :: Ptr b -> Int -> CPtrdiff -> IO () Source # peek :: Ptr CPtrdiff -> IO CPtrdiff Source # poke :: Ptr CPtrdiff -> CPtrdiff -> IO () Source #
Storable CSize
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSize -> Int Source # alignment :: CSize -> Int Source # peekElemOff :: Ptr CSize -> Int -> IO CSize Source # pokeElemOff :: Ptr CSize -> Int -> CSize -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CSize Source # pokeByteOff :: Ptr b -> Int -> CSize -> IO () Source # peek :: Ptr CSize -> IO CSize Source # poke :: Ptr CSize -> CSize -> IO () Source #
Storable CWchar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CWchar -> Int Source # alignment :: CWchar -> Int Source # peekElemOff :: Ptr CWchar -> Int -> IO CWchar Source # pokeElemOff :: Ptr CWchar -> Int -> CWchar -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CWchar Source # pokeByteOff :: Ptr b -> Int -> CWchar -> IO () Source # peek :: Ptr CWchar -> IO CWchar Source # poke :: Ptr CWchar -> CWchar -> IO () Source #
Storable CSigAtomic
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSigAtomic -> Int Source # alignment :: CSigAtomic -> Int Source # peekElemOff :: Ptr CSigAtomic -> Int -> IO CSigAtomic Source # pokeElemOff :: Ptr CSigAtomic -> Int -> CSigAtomic -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CSigAtomic Source # pokeByteOff :: Ptr b -> Int -> CSigAtomic -> IO () Source # peek :: Ptr CSigAtomic -> IO CSigAtomic Source # poke :: Ptr CSigAtomic -> CSigAtomic -> IO () Source #
Storable CClock
Instance details Defined in Foreign.C.Types Methods sizeOf :: CClock -> Int Source # alignment :: CClock -> Int Source # peekElemOff :: Ptr CClock -> Int -> IO CClock Source # pokeElemOff :: Ptr CClock -> Int -> CClock -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CClock Source # pokeByteOff :: Ptr b -> Int -> CClock -> IO () Source # peek :: Ptr CClock -> IO CClock Source # poke :: Ptr CClock -> CClock -> IO () Source #
Storable CTime
Instance details Defined in Foreign.C.Types Methods sizeOf :: CTime -> Int Source # alignment :: CTime -> Int Source # peekElemOff :: Ptr CTime -> Int -> IO CTime Source # pokeElemOff :: Ptr CTime -> Int -> CTime -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CTime Source # pokeByteOff :: Ptr b -> Int -> CTime -> IO () Source # peek :: Ptr CTime -> IO CTime Source # poke :: Ptr CTime -> CTime -> IO () Source #
Storable CUSeconds
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUSeconds -> Int Source # alignment :: CUSeconds -> Int Source # peekElemOff :: Ptr CUSeconds -> Int -> IO CUSeconds Source # pokeElemOff :: Ptr CUSeconds -> Int -> CUSeconds -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CUSeconds Source # pokeByteOff :: Ptr b -> Int -> CUSeconds -> IO () Source # peek :: Ptr CUSeconds -> IO CUSeconds Source # poke :: Ptr CUSeconds -> CUSeconds -> IO () Source #
Storable CSUSeconds
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSUSeconds -> Int Source # alignment :: CSUSeconds -> Int Source # peekElemOff :: Ptr CSUSeconds -> Int -> IO CSUSeconds Source # pokeElemOff :: Ptr CSUSeconds -> Int -> CSUSeconds -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CSUSeconds Source # pokeByteOff :: Ptr b -> Int -> CSUSeconds -> IO () Source # peek :: Ptr CSUSeconds -> IO CSUSeconds Source # poke :: Ptr CSUSeconds -> CSUSeconds -> IO () Source #
Storable CIntPtr
Instance details Defined in Foreign.C.Types Methods sizeOf :: CIntPtr -> Int Source # alignment :: CIntPtr -> Int Source # peekElemOff :: Ptr CIntPtr -> Int -> IO CIntPtr Source # pokeElemOff :: Ptr CIntPtr -> Int -> CIntPtr -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CIntPtr Source # pokeByteOff :: Ptr b -> Int -> CIntPtr -> IO () Source # peek :: Ptr CIntPtr -> IO CIntPtr Source # poke :: Ptr CIntPtr -> CIntPtr -> IO () Source #
Storable CUIntPtr
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUIntPtr -> Int Source # alignment :: CUIntPtr -> Int Source # peekElemOff :: Ptr CUIntPtr -> Int -> IO CUIntPtr Source # pokeElemOff :: Ptr CUIntPtr -> Int -> CUIntPtr -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CUIntPtr Source # pokeByteOff :: Ptr b -> Int -> CUIntPtr -> IO () Source # peek :: Ptr CUIntPtr -> IO CUIntPtr Source # poke :: Ptr CUIntPtr -> CUIntPtr -> IO () Source #
Storable CIntMax
Instance details Defined in Foreign.C.Types Methods sizeOf :: CIntMax -> Int Source # alignment :: CIntMax -> Int Source # peekElemOff :: Ptr CIntMax -> Int -> IO CIntMax Source # pokeElemOff :: Ptr CIntMax -> Int -> CIntMax -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CIntMax Source # pokeByteOff :: Ptr b -> Int -> CIntMax -> IO () Source # peek :: Ptr CIntMax -> IO CIntMax Source # poke :: Ptr CIntMax -> CIntMax -> IO () Source #
Storable CUIntMax
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUIntMax -> Int Source # alignment :: CUIntMax -> Int Source # peekElemOff :: Ptr CUIntMax -> Int -> IO CUIntMax Source # pokeElemOff :: Ptr CUIntMax -> Int -> CUIntMax -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CUIntMax Source # pokeByteOff :: Ptr b -> Int -> CUIntMax -> IO () Source # peek :: Ptr CUIntMax -> IO CUIntMax Source # poke :: Ptr CUIntMax -> CUIntMax -> IO () Source #
Storable WordPtr
Instance details Defined in Foreign.Ptr Methods sizeOf :: WordPtr -> Int Source # alignment :: WordPtr -> Int Source # peekElemOff :: Ptr WordPtr -> Int -> IO WordPtr Source # pokeElemOff :: Ptr WordPtr -> Int -> WordPtr -> IO () Source # peekByteOff :: Ptr b -> Int -> IO WordPtr Source # pokeByteOff :: Ptr b -> Int -> WordPtr -> IO () Source # peek :: Ptr WordPtr -> IO WordPtr Source # poke :: Ptr WordPtr -> WordPtr -> IO () Source #
Storable IntPtr
Instance details Defined in Foreign.Ptr Methods sizeOf :: IntPtr -> Int Source # alignment :: IntPtr -> Int Source # peekElemOff :: Ptr IntPtr -> Int -> IO IntPtr Source # pokeElemOff :: Ptr IntPtr -> Int -> IntPtr -> IO () Source # peekByteOff :: Ptr b -> Int -> IO IntPtr Source # pokeByteOff :: Ptr b -> Int -> IntPtr -> IO () Source # peek :: Ptr IntPtr -> IO IntPtr Source # poke :: Ptr IntPtr -> IntPtr -> IO () Source #
Storable Fingerprint	Since: base-4.4.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: Fingerprint -> Int Source # alignment :: Fingerprint -> Int Source # peekElemOff :: Ptr Fingerprint -> Int -> IO Fingerprint Source # pokeElemOff :: Ptr Fingerprint -> Int -> Fingerprint -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Fingerprint Source # pokeByteOff :: Ptr b -> Int -> Fingerprint -> IO () Source # peek :: Ptr Fingerprint -> IO Fingerprint Source # poke :: Ptr Fingerprint -> Fingerprint -> IO () Source #
Storable Int54
Instance details Defined in Text.JSON.Canonical.Types Methods sizeOf :: Int54 -> Int Source # alignment :: Int54 -> Int Source # peekElemOff :: Ptr Int54 -> Int -> IO Int54 Source # pokeElemOff :: Ptr Int54 -> Int -> Int54 -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int54 Source # pokeByteOff :: Ptr b -> Int -> Int54 -> IO () Source # peek :: Ptr Int54 -> IO Int54 Source # poke :: Ptr Int54 -> Int54 -> IO () Source #
Storable UUID	This `Storable` instance uses the memory layout as described in RFC 4122 , but in contrast to the `Binary` instance, the fields are stored in host byte order .
Instance details Defined in Data.UUID.Types.Internal Methods sizeOf :: UUID -> Int Source # alignment :: UUID -> Int Source # peekElemOff :: Ptr UUID -> Int -> IO UUID Source # pokeElemOff :: Ptr UUID -> Int -> UUID -> IO () Source # peekByteOff :: Ptr b -> Int -> IO UUID Source # pokeByteOff :: Ptr b -> Int -> UUID -> IO () Source # peek :: Ptr UUID -> IO UUID Source # poke :: Ptr UUID -> UUID -> IO () Source #
Storable CodePoint
Instance details Defined in Data.Text.Encoding Methods sizeOf :: CodePoint -> Int Source # alignment :: CodePoint -> Int Source # peekElemOff :: Ptr CodePoint -> Int -> IO CodePoint Source # pokeElemOff :: Ptr CodePoint -> Int -> CodePoint -> IO () Source # peekByteOff :: Ptr b -> Int -> IO CodePoint Source # pokeByteOff :: Ptr b -> Int -> CodePoint -> IO () Source # peek :: Ptr CodePoint -> IO CodePoint Source # poke :: Ptr CodePoint -> CodePoint -> IO () Source #
Storable DecoderState
Instance details Defined in Data.Text.Encoding Methods sizeOf :: DecoderState -> Int Source # alignment :: DecoderState -> Int Source # peekElemOff :: Ptr DecoderState -> Int -> IO DecoderState Source # pokeElemOff :: Ptr DecoderState -> Int -> DecoderState -> IO () Source # peekByteOff :: Ptr b -> Int -> IO DecoderState Source # pokeByteOff :: Ptr b -> Int -> DecoderState -> IO () Source # peek :: Ptr DecoderState -> IO DecoderState Source # poke :: Ptr DecoderState -> DecoderState -> IO () Source #
( Storable a, Integral a) => Storable ( Ratio a)	Since: base-4.8.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: Ratio a -> Int Source # alignment :: Ratio a -> Int Source # peekElemOff :: Ptr ( Ratio a) -> Int -> IO ( Ratio a) Source # pokeElemOff :: Ptr ( Ratio a) -> Int -> Ratio a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Ratio a) Source # pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () Source # peek :: Ptr ( Ratio a) -> IO ( Ratio a) Source # poke :: Ptr ( Ratio a) -> Ratio a -> IO () Source #
Storable ( StablePtr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: StablePtr a -> Int Source # alignment :: StablePtr a -> Int Source # peekElemOff :: Ptr ( StablePtr a) -> Int -> IO ( StablePtr a) Source # pokeElemOff :: Ptr ( StablePtr a) -> Int -> StablePtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( StablePtr a) Source # pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO () Source # peek :: Ptr ( StablePtr a) -> IO ( StablePtr a) Source # poke :: Ptr ( StablePtr a) -> StablePtr a -> IO () Source #
Storable ( Ptr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Ptr a -> Int Source # alignment :: Ptr a -> Int Source # peekElemOff :: Ptr ( Ptr a) -> Int -> IO ( Ptr a) Source # pokeElemOff :: Ptr ( Ptr a) -> Int -> Ptr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Ptr a) Source # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () Source # peek :: Ptr ( Ptr a) -> IO ( Ptr a) Source # poke :: Ptr ( Ptr a) -> Ptr a -> IO () Source #
Storable ( FunPtr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: FunPtr a -> Int Source # alignment :: FunPtr a -> Int Source # peekElemOff :: Ptr ( FunPtr a) -> Int -> IO ( FunPtr a) Source # pokeElemOff :: Ptr ( FunPtr a) -> Int -> FunPtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( FunPtr a) Source # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () Source # peek :: Ptr ( FunPtr a) -> IO ( FunPtr a) Source # poke :: Ptr ( FunPtr a) -> FunPtr a -> IO () Source #
Storable a => Storable ( Complex a)	Since: base-4.8.0.0
Instance details Defined in Data.Complex Methods sizeOf :: Complex a -> Int Source # alignment :: Complex a -> Int Source # peekElemOff :: Ptr ( Complex a) -> Int -> IO ( Complex a) Source # pokeElemOff :: Ptr ( Complex a) -> Int -> Complex a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Complex a) Source # pokeByteOff :: Ptr b -> Int -> Complex a -> IO () Source # peek :: Ptr ( Complex a) -> IO ( Complex a) Source # poke :: Ptr ( Complex a) -> Complex a -> IO () Source #
Storable a => Storable ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int Source # alignment :: Identity a -> Int Source # peekElemOff :: Ptr ( Identity a) -> Int -> IO ( Identity a) Source # pokeElemOff :: Ptr ( Identity a) -> Int -> Identity a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Identity a) Source # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () Source # peek :: Ptr ( Identity a) -> IO ( Identity a) Source # poke :: Ptr ( Identity a) -> Identity a -> IO () Source #
Storable a => Storable ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods sizeOf :: Down a -> Int Source # alignment :: Down a -> Int Source # peekElemOff :: Ptr ( Down a) -> Int -> IO ( Down a) Source # pokeElemOff :: Ptr ( Down a) -> Int -> Down a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Down a) Source # pokeByteOff :: Ptr b -> Int -> Down a -> IO () Source # peek :: Ptr ( Down a) -> IO ( Down a) Source # poke :: Ptr ( Down a) -> Down a -> IO () Source #
Prim a => Storable ( PrimStorable a)
Instance details Defined in Data.Primitive.Types Methods sizeOf :: PrimStorable a -> Int Source # alignment :: PrimStorable a -> Int Source # peekElemOff :: Ptr ( PrimStorable a) -> Int -> IO ( PrimStorable a) Source # pokeElemOff :: Ptr ( PrimStorable a) -> Int -> PrimStorable a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( PrimStorable a) Source # pokeByteOff :: Ptr b -> Int -> PrimStorable a -> IO () Source # peek :: Ptr ( PrimStorable a) -> IO ( PrimStorable a) Source # poke :: Ptr ( PrimStorable a) -> PrimStorable a -> IO () Source #
Storable g => Storable ( AtomicGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: AtomicGen g -> Int Source # alignment :: AtomicGen g -> Int Source # peekElemOff :: Ptr ( AtomicGen g) -> Int -> IO ( AtomicGen g) Source # pokeElemOff :: Ptr ( AtomicGen g) -> Int -> AtomicGen g -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( AtomicGen g) Source # pokeByteOff :: Ptr b -> Int -> AtomicGen g -> IO () Source # peek :: Ptr ( AtomicGen g) -> IO ( AtomicGen g) Source # poke :: Ptr ( AtomicGen g) -> AtomicGen g -> IO () Source #
Storable g => Storable ( IOGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: IOGen g -> Int Source # alignment :: IOGen g -> Int Source # peekElemOff :: Ptr ( IOGen g) -> Int -> IO ( IOGen g) Source # pokeElemOff :: Ptr ( IOGen g) -> Int -> IOGen g -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( IOGen g) Source # pokeByteOff :: Ptr b -> Int -> IOGen g -> IO () Source # peek :: Ptr ( IOGen g) -> IO ( IOGen g) Source # poke :: Ptr ( IOGen g) -> IOGen g -> IO () Source #
Storable g => Storable ( STGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: STGen g -> Int Source # alignment :: STGen g -> Int Source # peekElemOff :: Ptr ( STGen g) -> Int -> IO ( STGen g) Source # pokeElemOff :: Ptr ( STGen g) -> Int -> STGen g -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( STGen g) Source # pokeByteOff :: Ptr b -> Int -> STGen g -> IO () Source # peek :: Ptr ( STGen g) -> IO ( STGen g) Source # poke :: Ptr ( STGen g) -> STGen g -> IO () Source #
Storable g => Storable ( TGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: TGen g -> Int Source # alignment :: TGen g -> Int Source # peekElemOff :: Ptr ( TGen g) -> Int -> IO ( TGen g) Source # pokeElemOff :: Ptr ( TGen g) -> Int -> TGen g -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( TGen g) Source # pokeByteOff :: Ptr b -> Int -> TGen g -> IO () Source # peek :: Ptr ( TGen g) -> IO ( TGen g) Source # poke :: Ptr ( TGen g) -> TGen g -> IO () Source #
Storable g => Storable ( StateGen g)
Instance details Defined in System.Random.Internal Methods sizeOf :: StateGen g -> Int Source # alignment :: StateGen g -> Int Source # peekElemOff :: Ptr ( StateGen g) -> Int -> IO ( StateGen g) Source # pokeElemOff :: Ptr ( StateGen g) -> Int -> StateGen g -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( StateGen g) Source # pokeByteOff :: Ptr b -> Int -> StateGen g -> IO () Source # peek :: Ptr ( StateGen g) -> IO ( StateGen g) Source # poke :: Ptr ( StateGen g) -> StateGen g -> IO () Source #
Storable a => Storable ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int Source # alignment :: Const a b -> Int Source # peekElemOff :: Ptr ( Const a b) -> Int -> IO ( Const a b) Source # pokeElemOff :: Ptr ( Const a b) -> Int -> Const a b -> IO () Source # peekByteOff :: Ptr b0 -> Int -> IO ( Const a b) Source # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () Source # peek :: Ptr ( Const a b) -> IO ( Const a b) Source # poke :: Ptr ( Const a b) -> Const a b -> IO () Source #
Storable a => Storable ( Tagged s a)
Instance details Defined in Data.Tagged Methods sizeOf :: Tagged s a -> Int Source # alignment :: Tagged s a -> Int Source # peekElemOff :: Ptr ( Tagged s a) -> Int -> IO ( Tagged s a) Source # pokeElemOff :: Ptr ( Tagged s a) -> Int -> Tagged s a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Tagged s a) Source # pokeByteOff :: Ptr b -> Int -> Tagged s a -> IO () Source # peek :: Ptr ( Tagged s a) -> IO ( Tagged s a) Source # poke :: Ptr ( Tagged s a) -> Tagged s a -> IO () Source #

byteSwap64 :: Word64 -> Word64 Source #

Reverse order of bytes in Word64 .

Since: base-4.7.0.0

byteSwap32 :: Word32 -> Word32 Source #

Reverse order of bytes in Word32 .

Since: base-4.7.0.0

byteSwap16 :: Word16 -> Word16 Source #

Reverse order of bytes in Word16 .

Since: base-4.7.0.0

toTitle :: Char -> Char Source #

Convert a letter to the corresponding title-case or upper-case letter, if any. (Title case differs from upper case only for a small number of ligature letters.) Any other character is returned unchanged.

toUpper :: Char -> Char Source #

Convert a letter to the corresponding upper-case letter, if any. Any other character is returned unchanged.

isLower :: Char -> Bool Source #

Selects lower-case alphabetic Unicode characters (letters).

isUpper :: Char -> Bool Source #

Selects upper-case or title-case alphabetic Unicode characters (letters). Title case is used by a small number of letter ligatures like the single-character form of Lj .

isPrint :: Char -> Bool Source #

Selects printable Unicode characters (letters, numbers, marks, punctuation, symbols and spaces).

isControl :: Char -> Bool Source #

Selects control characters, which are the non-printing characters of the Latin-1 subset of Unicode.

isAlphaNum :: Char -> Bool Source #

Selects alphabetic or numeric Unicode characters.

Note that numeric digits outside the ASCII range, as well as numeric characters which aren't digits, are selected by this function but not by isDigit . Such characters may be part of identifiers but are not used by the printer and reader to represent numbers.

isHexDigit :: Char -> Bool Source #

Selects ASCII hexadecimal digits, i.e. '0' .. '9' , 'a' .. 'f' , 'A' .. 'F' .

isAscii :: Char -> Bool Source #

Selects the first 128 characters of the Unicode character set, corresponding to the ASCII character set.

toIntegralSized :: ( Integral a, Integral b, Bits a, Bits b) => a -> Maybe b Source #

Attempt to convert an Integral type a to an Integral type b using the size of the types as measured by Bits methods.

A simpler version of this function is:

toIntegral :: (Integral a, Integral b) => a -> Maybe b
toIntegral x
  | toInteger x == y = Just (fromInteger y)
  | otherwise        = Nothing
  where
    y = toInteger x

This version requires going through Integer , which can be inefficient. However, toIntegralSized is optimized to allow GHC to statically determine the relative type sizes (as measured by bitSizeMaybe and isSigned ) and avoid going through Integer for many types. (The implementation uses fromIntegral , which is itself optimized with rules for base types but may go through Integer for some type pairs.)

Since: base-4.8.0.0

popCountDefault :: ( Bits a, Num a) => a -> Int Source #

Default implementation for popCount .

This implementation is intentionally naive. Instances are expected to provide an optimized implementation for their size.

Since: base-4.6.0.0

testBitDefault :: ( Bits a, Num a) => a -> Int -> Bool Source #

Default implementation for testBit .

Note that: testBitDefault x i = (x .&. bit i) /= 0

Since: base-4.6.0.0

bitDefault :: ( Bits a, Num a) => Int -> a Source #

Default implementation for bit .

Note that: bitDefault i = 1 shiftL i

Since: base-4.6.0.0

class Eq a => Bits a where Source #

The Bits class defines bitwise operations over integral types.

Bits are numbered from 0 with bit 0 being the least significant bit.

Minimal complete definition

(.&.) , (.|.) , xor , complement , ( shift | shiftL , shiftR ), ( rotate | rotateL , rotateR ), bitSize , bitSizeMaybe , isSigned , testBit , bit , popCount

Methods

(.&.) :: a -> a -> a infixl 7 Source #

Bitwise "and"

(.|.) :: a -> a -> a infixl 5 Source #

Bitwise "or"

xor :: a -> a -> a infixl 6 Source #

Bitwise "xor"

complement :: a -> a Source #

Reverse all the bits in the argument

shift :: a -> Int -> a infixl 8 Source #

shift x i shifts x left by i bits if i is positive, or right by -i bits otherwise. Right shifts perform sign extension on signed number types; i.e. they fill the top bits with 1 if the x is negative and with 0 otherwise.

An instance can define either this unified shift or shiftL and shiftR , depending on which is more convenient for the type in question.

rotate :: a -> Int -> a infixl 8 Source #

rotate x i rotates x left by i bits if i is positive, or right by -i bits otherwise.

For unbounded types like Integer , rotate is equivalent to shift .

An instance can define either this unified rotate or rotateL and rotateR , depending on which is more convenient for the type in question.

zeroBits :: a Source #

zeroBits is the value with all bits unset.

The following laws ought to hold (for all valid bit indices n ):

```
clearBit zeroBits n == zeroBits
```
```
setBit   zeroBits n == bit n
```
```
testBit  zeroBits n == False
```
```
popCount zeroBits   == 0
```

This method uses clearBit ( bit 0) 0 as its default implementation (which ought to be equivalent to zeroBits for types which possess a 0th bit).

Since: base-4.7.0.0

bit :: Int -> a Source #

bit i is a value with the i th bit set and all other bits clear.

Can be implemented using bitDefault if a is also an instance of Num .

Instances

Instances details

Bits Bool	Interpret `Bool` as 1-bit bit-field Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods (.&.) :: Bool -> Bool -> Bool Source # (.\|.) :: Bool -> Bool -> Bool Source # xor :: Bool -> Bool -> Bool Source # complement :: Bool -> Bool Source # shift :: Bool -> Int -> Bool Source # rotate :: Bool -> Int -> Bool Source # zeroBits :: Bool Source # bit :: Int -> Bool Source # setBit :: Bool -> Int -> Bool Source # clearBit :: Bool -> Int -> Bool Source # complementBit :: Bool -> Int -> Bool Source # testBit :: Bool -> Int -> Bool Source # bitSizeMaybe :: Bool -> Maybe Int Source # bitSize :: Bool -> Int Source # isSigned :: Bool -> Bool Source # shiftL :: Bool -> Int -> Bool Source # unsafeShiftL :: Bool -> Int -> Bool Source # shiftR :: Bool -> Int -> Bool Source # unsafeShiftR :: Bool -> Int -> Bool Source # rotateL :: Bool -> Int -> Bool Source # rotateR :: Bool -> Int -> Bool Source # popCount :: Bool -> Int Source #
Bits Int	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Int -> Int -> Int Source # (.\|.) :: Int -> Int -> Int Source # xor :: Int -> Int -> Int Source # complement :: Int -> Int Source # shift :: Int -> Int -> Int Source # rotate :: Int -> Int -> Int Source # zeroBits :: Int Source # bit :: Int -> Int Source # setBit :: Int -> Int -> Int Source # clearBit :: Int -> Int -> Int Source # complementBit :: Int -> Int -> Int Source # testBit :: Int -> Int -> Bool Source # bitSizeMaybe :: Int -> Maybe Int Source # bitSize :: Int -> Int Source # isSigned :: Int -> Bool Source # shiftL :: Int -> Int -> Int Source # unsafeShiftL :: Int -> Int -> Int Source # shiftR :: Int -> Int -> Int Source # unsafeShiftR :: Int -> Int -> Int Source # rotateL :: Int -> Int -> Int Source # rotateR :: Int -> Int -> Int Source # popCount :: Int -> Int Source #
Bits Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int8 -> Int8 -> Int8 Source # (.\|.) :: Int8 -> Int8 -> Int8 Source # xor :: Int8 -> Int8 -> Int8 Source # complement :: Int8 -> Int8 Source # shift :: Int8 -> Int -> Int8 Source # rotate :: Int8 -> Int -> Int8 Source # zeroBits :: Int8 Source # bit :: Int -> Int8 Source # setBit :: Int8 -> Int -> Int8 Source # clearBit :: Int8 -> Int -> Int8 Source # complementBit :: Int8 -> Int -> Int8 Source # testBit :: Int8 -> Int -> Bool Source # bitSizeMaybe :: Int8 -> Maybe Int Source # bitSize :: Int8 -> Int Source # isSigned :: Int8 -> Bool Source # shiftL :: Int8 -> Int -> Int8 Source # unsafeShiftL :: Int8 -> Int -> Int8 Source # shiftR :: Int8 -> Int -> Int8 Source # unsafeShiftR :: Int8 -> Int -> Int8 Source # rotateL :: Int8 -> Int -> Int8 Source # rotateR :: Int8 -> Int -> Int8 Source # popCount :: Int8 -> Int Source #
Bits Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int16 -> Int16 -> Int16 Source # (.\|.) :: Int16 -> Int16 -> Int16 Source # xor :: Int16 -> Int16 -> Int16 Source # complement :: Int16 -> Int16 Source # shift :: Int16 -> Int -> Int16 Source # rotate :: Int16 -> Int -> Int16 Source # zeroBits :: Int16 Source # bit :: Int -> Int16 Source # setBit :: Int16 -> Int -> Int16 Source # clearBit :: Int16 -> Int -> Int16 Source # complementBit :: Int16 -> Int -> Int16 Source # testBit :: Int16 -> Int -> Bool Source # bitSizeMaybe :: Int16 -> Maybe Int Source # bitSize :: Int16 -> Int Source # isSigned :: Int16 -> Bool Source # shiftL :: Int16 -> Int -> Int16 Source # unsafeShiftL :: Int16 -> Int -> Int16 Source # shiftR :: Int16 -> Int -> Int16 Source # unsafeShiftR :: Int16 -> Int -> Int16 Source # rotateL :: Int16 -> Int -> Int16 Source # rotateR :: Int16 -> Int -> Int16 Source # popCount :: Int16 -> Int Source #
Bits Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int32 -> Int32 -> Int32 Source # (.\|.) :: Int32 -> Int32 -> Int32 Source # xor :: Int32 -> Int32 -> Int32 Source # complement :: Int32 -> Int32 Source # shift :: Int32 -> Int -> Int32 Source # rotate :: Int32 -> Int -> Int32 Source # zeroBits :: Int32 Source # bit :: Int -> Int32 Source # setBit :: Int32 -> Int -> Int32 Source # clearBit :: Int32 -> Int -> Int32 Source # complementBit :: Int32 -> Int -> Int32 Source # testBit :: Int32 -> Int -> Bool Source # bitSizeMaybe :: Int32 -> Maybe Int Source # bitSize :: Int32 -> Int Source # isSigned :: Int32 -> Bool Source # shiftL :: Int32 -> Int -> Int32 Source # unsafeShiftL :: Int32 -> Int -> Int32 Source # shiftR :: Int32 -> Int -> Int32 Source # unsafeShiftR :: Int32 -> Int -> Int32 Source # rotateL :: Int32 -> Int -> Int32 Source # rotateR :: Int32 -> Int -> Int32 Source # popCount :: Int32 -> Int Source #
Bits Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int64 -> Int64 -> Int64 Source # (.\|.) :: Int64 -> Int64 -> Int64 Source # xor :: Int64 -> Int64 -> Int64 Source # complement :: Int64 -> Int64 Source # shift :: Int64 -> Int -> Int64 Source # rotate :: Int64 -> Int -> Int64 Source # zeroBits :: Int64 Source # bit :: Int -> Int64 Source # setBit :: Int64 -> Int -> Int64 Source # clearBit :: Int64 -> Int -> Int64 Source # complementBit :: Int64 -> Int -> Int64 Source # testBit :: Int64 -> Int -> Bool Source # bitSizeMaybe :: Int64 -> Maybe Int Source # bitSize :: Int64 -> Int Source # isSigned :: Int64 -> Bool Source # shiftL :: Int64 -> Int -> Int64 Source # unsafeShiftL :: Int64 -> Int -> Int64 Source # shiftR :: Int64 -> Int -> Int64 Source # unsafeShiftR :: Int64 -> Int -> Int64 Source # rotateL :: Int64 -> Int -> Int64 Source # rotateR :: Int64 -> Int -> Int64 Source # popCount :: Int64 -> Int Source #
Bits Integer	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Integer -> Integer -> Integer Source # (.\|.) :: Integer -> Integer -> Integer Source # xor :: Integer -> Integer -> Integer Source # complement :: Integer -> Integer Source # shift :: Integer -> Int -> Integer Source # rotate :: Integer -> Int -> Integer Source # zeroBits :: Integer Source # bit :: Int -> Integer Source # setBit :: Integer -> Int -> Integer Source # clearBit :: Integer -> Int -> Integer Source # complementBit :: Integer -> Int -> Integer Source # testBit :: Integer -> Int -> Bool Source # bitSizeMaybe :: Integer -> Maybe Int Source # bitSize :: Integer -> Int Source # isSigned :: Integer -> Bool Source # shiftL :: Integer -> Int -> Integer Source # unsafeShiftL :: Integer -> Int -> Integer Source # shiftR :: Integer -> Int -> Integer Source # unsafeShiftR :: Integer -> Int -> Integer Source # rotateL :: Integer -> Int -> Integer Source # rotateR :: Integer -> Int -> Integer Source # popCount :: Integer -> Int Source #
Bits Natural	Since: base-4.8.0
Instance details Defined in Data.Bits Methods (.&.) :: Natural -> Natural -> Natural Source # (.\|.) :: Natural -> Natural -> Natural Source # xor :: Natural -> Natural -> Natural Source # complement :: Natural -> Natural Source # shift :: Natural -> Int -> Natural Source # rotate :: Natural -> Int -> Natural Source # zeroBits :: Natural Source # bit :: Int -> Natural Source # setBit :: Natural -> Int -> Natural Source # clearBit :: Natural -> Int -> Natural Source # complementBit :: Natural -> Int -> Natural Source # testBit :: Natural -> Int -> Bool Source # bitSizeMaybe :: Natural -> Maybe Int Source # bitSize :: Natural -> Int Source # isSigned :: Natural -> Bool Source # shiftL :: Natural -> Int -> Natural Source # unsafeShiftL :: Natural -> Int -> Natural Source # shiftR :: Natural -> Int -> Natural Source # unsafeShiftR :: Natural -> Int -> Natural Source # rotateL :: Natural -> Int -> Natural Source # rotateR :: Natural -> Int -> Natural Source # popCount :: Natural -> Int Source #
Bits Word	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Word -> Word -> Word Source # (.\|.) :: Word -> Word -> Word Source # xor :: Word -> Word -> Word Source # complement :: Word -> Word Source # shift :: Word -> Int -> Word Source # rotate :: Word -> Int -> Word Source # zeroBits :: Word Source # bit :: Int -> Word Source # setBit :: Word -> Int -> Word Source # clearBit :: Word -> Int -> Word Source # complementBit :: Word -> Int -> Word Source # testBit :: Word -> Int -> Bool Source # bitSizeMaybe :: Word -> Maybe Int Source # bitSize :: Word -> Int Source # isSigned :: Word -> Bool Source # shiftL :: Word -> Int -> Word Source # unsafeShiftL :: Word -> Int -> Word Source # shiftR :: Word -> Int -> Word Source # unsafeShiftR :: Word -> Int -> Word Source # rotateL :: Word -> Int -> Word Source # rotateR :: Word -> Int -> Word Source # popCount :: Word -> Int Source #
Bits Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word8 -> Word8 -> Word8 Source # (.\|.) :: Word8 -> Word8 -> Word8 Source # xor :: Word8 -> Word8 -> Word8 Source # complement :: Word8 -> Word8 Source # shift :: Word8 -> Int -> Word8 Source # rotate :: Word8 -> Int -> Word8 Source # zeroBits :: Word8 Source # bit :: Int -> Word8 Source # setBit :: Word8 -> Int -> Word8 Source # clearBit :: Word8 -> Int -> Word8 Source # complementBit :: Word8 -> Int -> Word8 Source # testBit :: Word8 -> Int -> Bool Source # bitSizeMaybe :: Word8 -> Maybe Int Source # bitSize :: Word8 -> Int Source # isSigned :: Word8 -> Bool Source # shiftL :: Word8 -> Int -> Word8 Source # unsafeShiftL :: Word8 -> Int -> Word8 Source # shiftR :: Word8 -> Int -> Word8 Source # unsafeShiftR :: Word8 -> Int -> Word8 Source # rotateL :: Word8 -> Int -> Word8 Source # rotateR :: Word8 -> Int -> Word8 Source # popCount :: Word8 -> Int Source #
Bits Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word16 -> Word16 -> Word16 Source # (.\|.) :: Word16 -> Word16 -> Word16 Source # xor :: Word16 -> Word16 -> Word16 Source # complement :: Word16 -> Word16 Source # shift :: Word16 -> Int -> Word16 Source # rotate :: Word16 -> Int -> Word16 Source # zeroBits :: Word16 Source # bit :: Int -> Word16 Source # setBit :: Word16 -> Int -> Word16 Source # clearBit :: Word16 -> Int -> Word16 Source # complementBit :: Word16 -> Int -> Word16 Source # testBit :: Word16 -> Int -> Bool Source # bitSizeMaybe :: Word16 -> Maybe Int Source # bitSize :: Word16 -> Int Source # isSigned :: Word16 -> Bool Source # shiftL :: Word16 -> Int -> Word16 Source # unsafeShiftL :: Word16 -> Int -> Word16 Source # shiftR :: Word16 -> Int -> Word16 Source # unsafeShiftR :: Word16 -> Int -> Word16 Source # rotateL :: Word16 -> Int -> Word16 Source # rotateR :: Word16 -> Int -> Word16 Source # popCount :: Word16 -> Int Source #
Bits Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word32 -> Word32 -> Word32 Source # (.\|.) :: Word32 -> Word32 -> Word32 Source # xor :: Word32 -> Word32 -> Word32 Source # complement :: Word32 -> Word32 Source # shift :: Word32 -> Int -> Word32 Source # rotate :: Word32 -> Int -> Word32 Source # zeroBits :: Word32 Source # bit :: Int -> Word32 Source # setBit :: Word32 -> Int -> Word32 Source # clearBit :: Word32 -> Int -> Word32 Source # complementBit :: Word32 -> Int -> Word32 Source # testBit :: Word32 -> Int -> Bool Source # bitSizeMaybe :: Word32 -> Maybe Int Source # bitSize :: Word32 -> Int Source # isSigned :: Word32 -> Bool Source # shiftL :: Word32 -> Int -> Word32 Source # unsafeShiftL :: Word32 -> Int -> Word32 Source # shiftR :: Word32 -> Int -> Word32 Source # unsafeShiftR :: Word32 -> Int -> Word32 Source # rotateL :: Word32 -> Int -> Word32 Source # rotateR :: Word32 -> Int -> Word32 Source # popCount :: Word32 -> Int Source #
Bits Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word64 -> Word64 -> Word64 Source # (.\|.) :: Word64 -> Word64 -> Word64 Source # xor :: Word64 -> Word64 -> Word64 Source # complement :: Word64 -> Word64 Source # shift :: Word64 -> Int -> Word64 Source # rotate :: Word64 -> Int -> Word64 Source # zeroBits :: Word64 Source # bit :: Int -> Word64 Source # setBit :: Word64 -> Int -> Word64 Source # clearBit :: Word64 -> Int -> Word64 Source # complementBit :: Word64 -> Int -> Word64 Source # testBit :: Word64 -> Int -> Bool Source # bitSizeMaybe :: Word64 -> Maybe Int Source # bitSize :: Word64 -> Int Source # isSigned :: Word64 -> Bool Source # shiftL :: Word64 -> Int -> Word64 Source # unsafeShiftL :: Word64 -> Int -> Word64 Source # shiftR :: Word64 -> Int -> Word64 Source # unsafeShiftR :: Word64 -> Int -> Word64 Source # rotateL :: Word64 -> Int -> Word64 Source # rotateR :: Word64 -> Int -> Word64 Source # popCount :: Word64 -> Int Source #
Bits CDev
Instance details Defined in System.Posix.Types Methods (.&.) :: CDev -> CDev -> CDev Source # (.\|.) :: CDev -> CDev -> CDev Source # xor :: CDev -> CDev -> CDev Source # complement :: CDev -> CDev Source # shift :: CDev -> Int -> CDev Source # rotate :: CDev -> Int -> CDev Source # zeroBits :: CDev Source # bit :: Int -> CDev Source # setBit :: CDev -> Int -> CDev Source # clearBit :: CDev -> Int -> CDev Source # complementBit :: CDev -> Int -> CDev Source # testBit :: CDev -> Int -> Bool Source # bitSizeMaybe :: CDev -> Maybe Int Source # bitSize :: CDev -> Int Source # isSigned :: CDev -> Bool Source # shiftL :: CDev -> Int -> CDev Source # unsafeShiftL :: CDev -> Int -> CDev Source # shiftR :: CDev -> Int -> CDev Source # unsafeShiftR :: CDev -> Int -> CDev Source # rotateL :: CDev -> Int -> CDev Source # rotateR :: CDev -> Int -> CDev Source # popCount :: CDev -> Int Source #
Bits CIno
Instance details Defined in System.Posix.Types Methods (.&.) :: CIno -> CIno -> CIno Source # (.\|.) :: CIno -> CIno -> CIno Source # xor :: CIno -> CIno -> CIno Source # complement :: CIno -> CIno Source # shift :: CIno -> Int -> CIno Source # rotate :: CIno -> Int -> CIno Source # zeroBits :: CIno Source # bit :: Int -> CIno Source # setBit :: CIno -> Int -> CIno Source # clearBit :: CIno -> Int -> CIno Source # complementBit :: CIno -> Int -> CIno Source # testBit :: CIno -> Int -> Bool Source # bitSizeMaybe :: CIno -> Maybe Int Source # bitSize :: CIno -> Int Source # isSigned :: CIno -> Bool Source # shiftL :: CIno -> Int -> CIno Source # unsafeShiftL :: CIno -> Int -> CIno Source # shiftR :: CIno -> Int -> CIno Source # unsafeShiftR :: CIno -> Int -> CIno Source # rotateL :: CIno -> Int -> CIno Source # rotateR :: CIno -> Int -> CIno Source # popCount :: CIno -> Int Source #
Bits CMode
Instance details Defined in System.Posix.Types Methods (.&.) :: CMode -> CMode -> CMode Source # (.\|.) :: CMode -> CMode -> CMode Source # xor :: CMode -> CMode -> CMode Source # complement :: CMode -> CMode Source # shift :: CMode -> Int -> CMode Source # rotate :: CMode -> Int -> CMode Source # zeroBits :: CMode Source # bit :: Int -> CMode Source # setBit :: CMode -> Int -> CMode Source # clearBit :: CMode -> Int -> CMode Source # complementBit :: CMode -> Int -> CMode Source # testBit :: CMode -> Int -> Bool Source # bitSizeMaybe :: CMode -> Maybe Int Source # bitSize :: CMode -> Int Source # isSigned :: CMode -> Bool Source # shiftL :: CMode -> Int -> CMode Source # unsafeShiftL :: CMode -> Int -> CMode Source # shiftR :: CMode -> Int -> CMode Source # unsafeShiftR :: CMode -> Int -> CMode Source # rotateL :: CMode -> Int -> CMode Source # rotateR :: CMode -> Int -> CMode Source # popCount :: CMode -> Int Source #
Bits COff
Instance details Defined in System.Posix.Types Methods (.&.) :: COff -> COff -> COff Source # (.\|.) :: COff -> COff -> COff Source # xor :: COff -> COff -> COff Source # complement :: COff -> COff Source # shift :: COff -> Int -> COff Source # rotate :: COff -> Int -> COff Source # zeroBits :: COff Source # bit :: Int -> COff Source # setBit :: COff -> Int -> COff Source # clearBit :: COff -> Int -> COff Source # complementBit :: COff -> Int -> COff Source # testBit :: COff -> Int -> Bool Source # bitSizeMaybe :: COff -> Maybe Int Source # bitSize :: COff -> Int Source # isSigned :: COff -> Bool Source # shiftL :: COff -> Int -> COff Source # unsafeShiftL :: COff -> Int -> COff Source # shiftR :: COff -> Int -> COff Source # unsafeShiftR :: COff -> Int -> COff Source # rotateL :: COff -> Int -> COff Source # rotateR :: COff -> Int -> COff Source # popCount :: COff -> Int Source #
Bits CPid
Instance details Defined in System.Posix.Types Methods (.&.) :: CPid -> CPid -> CPid Source # (.\|.) :: CPid -> CPid -> CPid Source # xor :: CPid -> CPid -> CPid Source # complement :: CPid -> CPid Source # shift :: CPid -> Int -> CPid Source # rotate :: CPid -> Int -> CPid Source # zeroBits :: CPid Source # bit :: Int -> CPid Source # setBit :: CPid -> Int -> CPid Source # clearBit :: CPid -> Int -> CPid Source # complementBit :: CPid -> Int -> CPid Source # testBit :: CPid -> Int -> Bool Source # bitSizeMaybe :: CPid -> Maybe Int Source # bitSize :: CPid -> Int Source # isSigned :: CPid -> Bool Source # shiftL :: CPid -> Int -> CPid Source # unsafeShiftL :: CPid -> Int -> CPid Source # shiftR :: CPid -> Int -> CPid Source # unsafeShiftR :: CPid -> Int -> CPid Source # rotateL :: CPid -> Int -> CPid Source # rotateR :: CPid -> Int -> CPid Source # popCount :: CPid -> Int Source #
Bits CSsize
Instance details Defined in System.Posix.Types Methods (.&.) :: CSsize -> CSsize -> CSsize Source # (.\|.) :: CSsize -> CSsize -> CSsize Source # xor :: CSsize -> CSsize -> CSsize Source # complement :: CSsize -> CSsize Source # shift :: CSsize -> Int -> CSsize Source # rotate :: CSsize -> Int -> CSsize Source # zeroBits :: CSsize Source # bit :: Int -> CSsize Source # setBit :: CSsize -> Int -> CSsize Source # clearBit :: CSsize -> Int -> CSsize Source # complementBit :: CSsize -> Int -> CSsize Source # testBit :: CSsize -> Int -> Bool Source # bitSizeMaybe :: CSsize -> Maybe Int Source # bitSize :: CSsize -> Int Source # isSigned :: CSsize -> Bool Source # shiftL :: CSsize -> Int -> CSsize Source # unsafeShiftL :: CSsize -> Int -> CSsize Source # shiftR :: CSsize -> Int -> CSsize Source # unsafeShiftR :: CSsize -> Int -> CSsize Source # rotateL :: CSsize -> Int -> CSsize Source # rotateR :: CSsize -> Int -> CSsize Source # popCount :: CSsize -> Int Source #
Bits CGid
Instance details Defined in System.Posix.Types Methods (.&.) :: CGid -> CGid -> CGid Source # (.\|.) :: CGid -> CGid -> CGid Source # xor :: CGid -> CGid -> CGid Source # complement :: CGid -> CGid Source # shift :: CGid -> Int -> CGid Source # rotate :: CGid -> Int -> CGid Source # zeroBits :: CGid Source # bit :: Int -> CGid Source # setBit :: CGid -> Int -> CGid Source # clearBit :: CGid -> Int -> CGid Source # complementBit :: CGid -> Int -> CGid Source # testBit :: CGid -> Int -> Bool Source # bitSizeMaybe :: CGid -> Maybe Int Source # bitSize :: CGid -> Int Source # isSigned :: CGid -> Bool Source # shiftL :: CGid -> Int -> CGid Source # unsafeShiftL :: CGid -> Int -> CGid Source # shiftR :: CGid -> Int -> CGid Source # unsafeShiftR :: CGid -> Int -> CGid Source # rotateL :: CGid -> Int -> CGid Source # rotateR :: CGid -> Int -> CGid Source # popCount :: CGid -> Int Source #
Bits CNlink
Instance details Defined in System.Posix.Types Methods (.&.) :: CNlink -> CNlink -> CNlink Source # (.\|.) :: CNlink -> CNlink -> CNlink Source # xor :: CNlink -> CNlink -> CNlink Source # complement :: CNlink -> CNlink Source # shift :: CNlink -> Int -> CNlink Source # rotate :: CNlink -> Int -> CNlink Source # zeroBits :: CNlink Source # bit :: Int -> CNlink Source # setBit :: CNlink -> Int -> CNlink Source # clearBit :: CNlink -> Int -> CNlink Source # complementBit :: CNlink -> Int -> CNlink Source # testBit :: CNlink -> Int -> Bool Source # bitSizeMaybe :: CNlink -> Maybe Int Source # bitSize :: CNlink -> Int Source # isSigned :: CNlink -> Bool Source # shiftL :: CNlink -> Int -> CNlink Source # unsafeShiftL :: CNlink -> Int -> CNlink Source # shiftR :: CNlink -> Int -> CNlink Source # unsafeShiftR :: CNlink -> Int -> CNlink Source # rotateL :: CNlink -> Int -> CNlink Source # rotateR :: CNlink -> Int -> CNlink Source # popCount :: CNlink -> Int Source #
Bits CUid
Instance details Defined in System.Posix.Types Methods (.&.) :: CUid -> CUid -> CUid Source # (.\|.) :: CUid -> CUid -> CUid Source # xor :: CUid -> CUid -> CUid Source # complement :: CUid -> CUid Source # shift :: CUid -> Int -> CUid Source # rotate :: CUid -> Int -> CUid Source # zeroBits :: CUid Source # bit :: Int -> CUid Source # setBit :: CUid -> Int -> CUid Source # clearBit :: CUid -> Int -> CUid Source # complementBit :: CUid -> Int -> CUid Source # testBit :: CUid -> Int -> Bool Source # bitSizeMaybe :: CUid -> Maybe Int Source # bitSize :: CUid -> Int Source # isSigned :: CUid -> Bool Source # shiftL :: CUid -> Int -> CUid Source # unsafeShiftL :: CUid -> Int -> CUid Source # shiftR :: CUid -> Int -> CUid Source # unsafeShiftR :: CUid -> Int -> CUid Source # rotateL :: CUid -> Int -> CUid Source # rotateR :: CUid -> Int -> CUid Source # popCount :: CUid -> Int Source #
Bits CTcflag
Instance details Defined in System.Posix.Types Methods (.&.) :: CTcflag -> CTcflag -> CTcflag Source # (.\|.) :: CTcflag -> CTcflag -> CTcflag Source # xor :: CTcflag -> CTcflag -> CTcflag Source # complement :: CTcflag -> CTcflag Source # shift :: CTcflag -> Int -> CTcflag Source # rotate :: CTcflag -> Int -> CTcflag Source # zeroBits :: CTcflag Source # bit :: Int -> CTcflag Source # setBit :: CTcflag -> Int -> CTcflag Source # clearBit :: CTcflag -> Int -> CTcflag Source # complementBit :: CTcflag -> Int -> CTcflag Source # testBit :: CTcflag -> Int -> Bool Source # bitSizeMaybe :: CTcflag -> Maybe Int Source # bitSize :: CTcflag -> Int Source # isSigned :: CTcflag -> Bool Source # shiftL :: CTcflag -> Int -> CTcflag Source # unsafeShiftL :: CTcflag -> Int -> CTcflag Source # shiftR :: CTcflag -> Int -> CTcflag Source # unsafeShiftR :: CTcflag -> Int -> CTcflag Source # rotateL :: CTcflag -> Int -> CTcflag Source # rotateR :: CTcflag -> Int -> CTcflag Source # popCount :: CTcflag -> Int Source #
Bits CRLim
Instance details Defined in System.Posix.Types Methods (.&.) :: CRLim -> CRLim -> CRLim Source # (.\|.) :: CRLim -> CRLim -> CRLim Source # xor :: CRLim -> CRLim -> CRLim Source # complement :: CRLim -> CRLim Source # shift :: CRLim -> Int -> CRLim Source # rotate :: CRLim -> Int -> CRLim Source # zeroBits :: CRLim Source # bit :: Int -> CRLim Source # setBit :: CRLim -> Int -> CRLim Source # clearBit :: CRLim -> Int -> CRLim Source # complementBit :: CRLim -> Int -> CRLim Source # testBit :: CRLim -> Int -> Bool Source # bitSizeMaybe :: CRLim -> Maybe Int Source # bitSize :: CRLim -> Int Source # isSigned :: CRLim -> Bool Source # shiftL :: CRLim -> Int -> CRLim Source # unsafeShiftL :: CRLim -> Int -> CRLim Source # shiftR :: CRLim -> Int -> CRLim Source # unsafeShiftR :: CRLim -> Int -> CRLim Source # rotateL :: CRLim -> Int -> CRLim Source # rotateR :: CRLim -> Int -> CRLim Source # popCount :: CRLim -> Int Source #
Bits CBlkSize
Instance details Defined in System.Posix.Types Methods (.&.) :: CBlkSize -> CBlkSize -> CBlkSize Source # (.\|.) :: CBlkSize -> CBlkSize -> CBlkSize Source # xor :: CBlkSize -> CBlkSize -> CBlkSize Source # complement :: CBlkSize -> CBlkSize Source # shift :: CBlkSize -> Int -> CBlkSize Source # rotate :: CBlkSize -> Int -> CBlkSize Source # zeroBits :: CBlkSize Source # bit :: Int -> CBlkSize Source # setBit :: CBlkSize -> Int -> CBlkSize Source # clearBit :: CBlkSize -> Int -> CBlkSize Source # complementBit :: CBlkSize -> Int -> CBlkSize Source # testBit :: CBlkSize -> Int -> Bool Source # bitSizeMaybe :: CBlkSize -> Maybe Int Source # bitSize :: CBlkSize -> Int Source # isSigned :: CBlkSize -> Bool Source # shiftL :: CBlkSize -> Int -> CBlkSize Source # unsafeShiftL :: CBlkSize -> Int -> CBlkSize Source # shiftR :: CBlkSize -> Int -> CBlkSize Source # unsafeShiftR :: CBlkSize -> Int -> CBlkSize Source # rotateL :: CBlkSize -> Int -> CBlkSize Source # rotateR :: CBlkSize -> Int -> CBlkSize Source # popCount :: CBlkSize -> Int Source #
Bits CBlkCnt
Instance details Defined in System.Posix.Types Methods (.&.) :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # (.\|.) :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # xor :: CBlkCnt -> CBlkCnt -> CBlkCnt Source # complement :: CBlkCnt -> CBlkCnt Source # shift :: CBlkCnt -> Int -> CBlkCnt Source # rotate :: CBlkCnt -> Int -> CBlkCnt Source # zeroBits :: CBlkCnt Source # bit :: Int -> CBlkCnt Source # setBit :: CBlkCnt -> Int -> CBlkCnt Source # clearBit :: CBlkCnt -> Int -> CBlkCnt Source # complementBit :: CBlkCnt -> Int -> CBlkCnt Source # testBit :: CBlkCnt -> Int -> Bool Source # bitSizeMaybe :: CBlkCnt -> Maybe Int Source # bitSize :: CBlkCnt -> Int Source # isSigned :: CBlkCnt -> Bool Source # shiftL :: CBlkCnt -> Int -> CBlkCnt Source # unsafeShiftL :: CBlkCnt -> Int -> CBlkCnt Source # shiftR :: CBlkCnt -> Int -> CBlkCnt Source # unsafeShiftR :: CBlkCnt -> Int -> CBlkCnt Source # rotateL :: CBlkCnt -> Int -> CBlkCnt Source # rotateR :: CBlkCnt -> Int -> CBlkCnt Source # popCount :: CBlkCnt -> Int Source #
Bits CClockId
Instance details Defined in System.Posix.Types Methods (.&.) :: CClockId -> CClockId -> CClockId Source # (.\|.) :: CClockId -> CClockId -> CClockId Source # xor :: CClockId -> CClockId -> CClockId Source # complement :: CClockId -> CClockId Source # shift :: CClockId -> Int -> CClockId Source # rotate :: CClockId -> Int -> CClockId Source # zeroBits :: CClockId Source # bit :: Int -> CClockId Source # setBit :: CClockId -> Int -> CClockId Source # clearBit :: CClockId -> Int -> CClockId Source # complementBit :: CClockId -> Int -> CClockId Source # testBit :: CClockId -> Int -> Bool Source # bitSizeMaybe :: CClockId -> Maybe Int Source # bitSize :: CClockId -> Int Source # isSigned :: CClockId -> Bool Source # shiftL :: CClockId -> Int -> CClockId Source # unsafeShiftL :: CClockId -> Int -> CClockId Source # shiftR :: CClockId -> Int -> CClockId Source # unsafeShiftR :: CClockId -> Int -> CClockId Source # rotateL :: CClockId -> Int -> CClockId Source # rotateR :: CClockId -> Int -> CClockId Source # popCount :: CClockId -> Int Source #
Bits CFsBlkCnt
Instance details Defined in System.Posix.Types Methods (.&.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # (.\|.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # xor :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source # complement :: CFsBlkCnt -> CFsBlkCnt Source # shift :: CFsBlkCnt -> Int -> CFsBlkCnt Source # rotate :: CFsBlkCnt -> Int -> CFsBlkCnt Source # zeroBits :: CFsBlkCnt Source # bit :: Int -> CFsBlkCnt Source # setBit :: CFsBlkCnt -> Int -> CFsBlkCnt Source # clearBit :: CFsBlkCnt -> Int -> CFsBlkCnt Source # complementBit :: CFsBlkCnt -> Int -> CFsBlkCnt Source # testBit :: CFsBlkCnt -> Int -> Bool Source # bitSizeMaybe :: CFsBlkCnt -> Maybe Int Source # bitSize :: CFsBlkCnt -> Int Source # isSigned :: CFsBlkCnt -> Bool Source # shiftL :: CFsBlkCnt -> Int -> CFsBlkCnt Source # unsafeShiftL :: CFsBlkCnt -> Int -> CFsBlkCnt Source # shiftR :: CFsBlkCnt -> Int -> CFsBlkCnt Source # unsafeShiftR :: CFsBlkCnt -> Int -> CFsBlkCnt Source # rotateL :: CFsBlkCnt -> Int -> CFsBlkCnt Source # rotateR :: CFsBlkCnt -> Int -> CFsBlkCnt Source # popCount :: CFsBlkCnt -> Int Source #
Bits CFsFilCnt
Instance details Defined in System.Posix.Types Methods (.&.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # (.\|.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # xor :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source # complement :: CFsFilCnt -> CFsFilCnt Source # shift :: CFsFilCnt -> Int -> CFsFilCnt Source # rotate :: CFsFilCnt -> Int -> CFsFilCnt Source # zeroBits :: CFsFilCnt Source # bit :: Int -> CFsFilCnt Source # setBit :: CFsFilCnt -> Int -> CFsFilCnt Source # clearBit :: CFsFilCnt -> Int -> CFsFilCnt Source # complementBit :: CFsFilCnt -> Int -> CFsFilCnt Source # testBit :: CFsFilCnt -> Int -> Bool Source # bitSizeMaybe :: CFsFilCnt -> Maybe Int Source # bitSize :: CFsFilCnt -> Int Source # isSigned :: CFsFilCnt -> Bool Source # shiftL :: CFsFilCnt -> Int -> CFsFilCnt Source # unsafeShiftL :: CFsFilCnt -> Int -> CFsFilCnt Source # shiftR :: CFsFilCnt -> Int -> CFsFilCnt Source # unsafeShiftR :: CFsFilCnt -> Int -> CFsFilCnt Source # rotateL :: CFsFilCnt -> Int -> CFsFilCnt Source # rotateR :: CFsFilCnt -> Int -> CFsFilCnt Source # popCount :: CFsFilCnt -> Int Source #
Bits CId
Instance details Defined in System.Posix.Types Methods (.&.) :: CId -> CId -> CId Source # (.\|.) :: CId -> CId -> CId Source # xor :: CId -> CId -> CId Source # complement :: CId -> CId Source # shift :: CId -> Int -> CId Source # rotate :: CId -> Int -> CId Source # zeroBits :: CId Source # bit :: Int -> CId Source # setBit :: CId -> Int -> CId Source # clearBit :: CId -> Int -> CId Source # complementBit :: CId -> Int -> CId Source # testBit :: CId -> Int -> Bool Source # bitSizeMaybe :: CId -> Maybe Int Source # bitSize :: CId -> Int Source # isSigned :: CId -> Bool Source # shiftL :: CId -> Int -> CId Source # unsafeShiftL :: CId -> Int -> CId Source # shiftR :: CId -> Int -> CId Source # unsafeShiftR :: CId -> Int -> CId Source # rotateL :: CId -> Int -> CId Source # rotateR :: CId -> Int -> CId Source # popCount :: CId -> Int Source #
Bits CKey
Instance details Defined in System.Posix.Types Methods (.&.) :: CKey -> CKey -> CKey Source # (.\|.) :: CKey -> CKey -> CKey Source # xor :: CKey -> CKey -> CKey Source # complement :: CKey -> CKey Source # shift :: CKey -> Int -> CKey Source # rotate :: CKey -> Int -> CKey Source # zeroBits :: CKey Source # bit :: Int -> CKey Source # setBit :: CKey -> Int -> CKey Source # clearBit :: CKey -> Int -> CKey Source # complementBit :: CKey -> Int -> CKey Source # testBit :: CKey -> Int -> Bool Source # bitSizeMaybe :: CKey -> Maybe Int Source # bitSize :: CKey -> Int Source # isSigned :: CKey -> Bool Source # shiftL :: CKey -> Int -> CKey Source # unsafeShiftL :: CKey -> Int -> CKey Source # shiftR :: CKey -> Int -> CKey Source # unsafeShiftR :: CKey -> Int -> CKey Source # rotateL :: CKey -> Int -> CKey Source # rotateR :: CKey -> Int -> CKey Source # popCount :: CKey -> Int Source #
Bits CSocklen
Instance details Defined in System.Posix.Types Methods (.&.) :: CSocklen -> CSocklen -> CSocklen Source # (.\|.) :: CSocklen -> CSocklen -> CSocklen Source # xor :: CSocklen -> CSocklen -> CSocklen Source # complement :: CSocklen -> CSocklen Source # shift :: CSocklen -> Int -> CSocklen Source # rotate :: CSocklen -> Int -> CSocklen Source # zeroBits :: CSocklen Source # bit :: Int -> CSocklen Source # setBit :: CSocklen -> Int -> CSocklen Source # clearBit :: CSocklen -> Int -> CSocklen Source # complementBit :: CSocklen -> Int -> CSocklen Source # testBit :: CSocklen -> Int -> Bool Source # bitSizeMaybe :: CSocklen -> Maybe Int Source # bitSize :: CSocklen -> Int Source # isSigned :: CSocklen -> Bool Source # shiftL :: CSocklen -> Int -> CSocklen Source # unsafeShiftL :: CSocklen -> Int -> CSocklen Source # shiftR :: CSocklen -> Int -> CSocklen Source # unsafeShiftR :: CSocklen -> Int -> CSocklen Source # rotateL :: CSocklen -> Int -> CSocklen Source # rotateR :: CSocklen -> Int -> CSocklen Source # popCount :: CSocklen -> Int Source #
Bits CNfds
Instance details Defined in System.Posix.Types Methods (.&.) :: CNfds -> CNfds -> CNfds Source # (.\|.) :: CNfds -> CNfds -> CNfds Source # xor :: CNfds -> CNfds -> CNfds Source # complement :: CNfds -> CNfds Source # shift :: CNfds -> Int -> CNfds Source # rotate :: CNfds -> Int -> CNfds Source # zeroBits :: CNfds Source # bit :: Int -> CNfds Source # setBit :: CNfds -> Int -> CNfds Source # clearBit :: CNfds -> Int -> CNfds Source # complementBit :: CNfds -> Int -> CNfds Source # testBit :: CNfds -> Int -> Bool Source # bitSizeMaybe :: CNfds -> Maybe Int Source # bitSize :: CNfds -> Int Source # isSigned :: CNfds -> Bool Source # shiftL :: CNfds -> Int -> CNfds Source # unsafeShiftL :: CNfds -> Int -> CNfds Source # shiftR :: CNfds -> Int -> CNfds Source # unsafeShiftR :: CNfds -> Int -> CNfds Source # rotateL :: CNfds -> Int -> CNfds Source # rotateR :: CNfds -> Int -> CNfds Source # popCount :: CNfds -> Int Source #
Bits Fd
Instance details Defined in System.Posix.Types Methods (.&.) :: Fd -> Fd -> Fd Source # (.\|.) :: Fd -> Fd -> Fd Source # xor :: Fd -> Fd -> Fd Source # complement :: Fd -> Fd Source # shift :: Fd -> Int -> Fd Source # rotate :: Fd -> Int -> Fd Source # zeroBits :: Fd Source # bit :: Int -> Fd Source # setBit :: Fd -> Int -> Fd Source # clearBit :: Fd -> Int -> Fd Source # complementBit :: Fd -> Int -> Fd Source # testBit :: Fd -> Int -> Bool Source # bitSizeMaybe :: Fd -> Maybe Int Source # bitSize :: Fd -> Int Source # isSigned :: Fd -> Bool Source # shiftL :: Fd -> Int -> Fd Source # unsafeShiftL :: Fd -> Int -> Fd Source # shiftR :: Fd -> Int -> Fd Source # unsafeShiftR :: Fd -> Int -> Fd Source # rotateL :: Fd -> Int -> Fd Source # rotateR :: Fd -> Int -> Fd Source # popCount :: Fd -> Int Source #
Bits CChar
Instance details Defined in Foreign.C.Types Methods (.&.) :: CChar -> CChar -> CChar Source # (.\|.) :: CChar -> CChar -> CChar Source # xor :: CChar -> CChar -> CChar Source # complement :: CChar -> CChar Source # shift :: CChar -> Int -> CChar Source # rotate :: CChar -> Int -> CChar Source # zeroBits :: CChar Source # bit :: Int -> CChar Source # setBit :: CChar -> Int -> CChar Source # clearBit :: CChar -> Int -> CChar Source # complementBit :: CChar -> Int -> CChar Source # testBit :: CChar -> Int -> Bool Source # bitSizeMaybe :: CChar -> Maybe Int Source # bitSize :: CChar -> Int Source # isSigned :: CChar -> Bool Source # shiftL :: CChar -> Int -> CChar Source # unsafeShiftL :: CChar -> Int -> CChar Source # shiftR :: CChar -> Int -> CChar Source # unsafeShiftR :: CChar -> Int -> CChar Source # rotateL :: CChar -> Int -> CChar Source # rotateR :: CChar -> Int -> CChar Source # popCount :: CChar -> Int Source #
Bits CSChar
Instance details Defined in Foreign.C.Types Methods (.&.) :: CSChar -> CSChar -> CSChar Source # (.\|.) :: CSChar -> CSChar -> CSChar Source # xor :: CSChar -> CSChar -> CSChar Source # complement :: CSChar -> CSChar Source # shift :: CSChar -> Int -> CSChar Source # rotate :: CSChar -> Int -> CSChar Source # zeroBits :: CSChar Source # bit :: Int -> CSChar Source # setBit :: CSChar -> Int -> CSChar Source # clearBit :: CSChar -> Int -> CSChar Source # complementBit :: CSChar -> Int -> CSChar Source # testBit :: CSChar -> Int -> Bool Source # bitSizeMaybe :: CSChar -> Maybe Int Source # bitSize :: CSChar -> Int Source # isSigned :: CSChar -> Bool Source # shiftL :: CSChar -> Int -> CSChar Source # unsafeShiftL :: CSChar -> Int -> CSChar Source # shiftR :: CSChar -> Int -> CSChar Source # unsafeShiftR :: CSChar -> Int -> CSChar Source # rotateL :: CSChar -> Int -> CSChar Source # rotateR :: CSChar -> Int -> CSChar Source # popCount :: CSChar -> Int Source #
Bits CUChar
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUChar -> CUChar -> CUChar Source # (.\|.) :: CUChar -> CUChar -> CUChar Source # xor :: CUChar -> CUChar -> CUChar Source # complement :: CUChar -> CUChar Source # shift :: CUChar -> Int -> CUChar Source # rotate :: CUChar -> Int -> CUChar Source # zeroBits :: CUChar Source # bit :: Int -> CUChar Source # setBit :: CUChar -> Int -> CUChar Source # clearBit :: CUChar -> Int -> CUChar Source # complementBit :: CUChar -> Int -> CUChar Source # testBit :: CUChar -> Int -> Bool Source # bitSizeMaybe :: CUChar -> Maybe Int Source # bitSize :: CUChar -> Int Source # isSigned :: CUChar -> Bool Source # shiftL :: CUChar -> Int -> CUChar Source # unsafeShiftL :: CUChar -> Int -> CUChar Source # shiftR :: CUChar -> Int -> CUChar Source # unsafeShiftR :: CUChar -> Int -> CUChar Source # rotateL :: CUChar -> Int -> CUChar Source # rotateR :: CUChar -> Int -> CUChar Source # popCount :: CUChar -> Int Source #
Bits CShort
Instance details Defined in Foreign.C.Types Methods (.&.) :: CShort -> CShort -> CShort Source # (.\|.) :: CShort -> CShort -> CShort Source # xor :: CShort -> CShort -> CShort Source # complement :: CShort -> CShort Source # shift :: CShort -> Int -> CShort Source # rotate :: CShort -> Int -> CShort Source # zeroBits :: CShort Source # bit :: Int -> CShort Source # setBit :: CShort -> Int -> CShort Source # clearBit :: CShort -> Int -> CShort Source # complementBit :: CShort -> Int -> CShort Source # testBit :: CShort -> Int -> Bool Source # bitSizeMaybe :: CShort -> Maybe Int Source # bitSize :: CShort -> Int Source # isSigned :: CShort -> Bool Source # shiftL :: CShort -> Int -> CShort Source # unsafeShiftL :: CShort -> Int -> CShort Source # shiftR :: CShort -> Int -> CShort Source # unsafeShiftR :: CShort -> Int -> CShort Source # rotateL :: CShort -> Int -> CShort Source # rotateR :: CShort -> Int -> CShort Source # popCount :: CShort -> Int Source #
Bits CUShort
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUShort -> CUShort -> CUShort Source # (.\|.) :: CUShort -> CUShort -> CUShort Source # xor :: CUShort -> CUShort -> CUShort Source # complement :: CUShort -> CUShort Source # shift :: CUShort -> Int -> CUShort Source # rotate :: CUShort -> Int -> CUShort Source # zeroBits :: CUShort Source # bit :: Int -> CUShort Source # setBit :: CUShort -> Int -> CUShort Source # clearBit :: CUShort -> Int -> CUShort Source # complementBit :: CUShort -> Int -> CUShort Source # testBit :: CUShort -> Int -> Bool Source # bitSizeMaybe :: CUShort -> Maybe Int Source # bitSize :: CUShort -> Int Source # isSigned :: CUShort -> Bool Source # shiftL :: CUShort -> Int -> CUShort Source # unsafeShiftL :: CUShort -> Int -> CUShort Source # shiftR :: CUShort -> Int -> CUShort Source # unsafeShiftR :: CUShort -> Int -> CUShort Source # rotateL :: CUShort -> Int -> CUShort Source # rotateR :: CUShort -> Int -> CUShort Source # popCount :: CUShort -> Int Source #
Bits CInt
Instance details Defined in Foreign.C.Types Methods (.&.) :: CInt -> CInt -> CInt Source # (.\|.) :: CInt -> CInt -> CInt Source # xor :: CInt -> CInt -> CInt Source # complement :: CInt -> CInt Source # shift :: CInt -> Int -> CInt Source # rotate :: CInt -> Int -> CInt Source # zeroBits :: CInt Source # bit :: Int -> CInt Source # setBit :: CInt -> Int -> CInt Source # clearBit :: CInt -> Int -> CInt Source # complementBit :: CInt -> Int -> CInt Source # testBit :: CInt -> Int -> Bool Source # bitSizeMaybe :: CInt -> Maybe Int Source # bitSize :: CInt -> Int Source # isSigned :: CInt -> Bool Source # shiftL :: CInt -> Int -> CInt Source # unsafeShiftL :: CInt -> Int -> CInt Source # shiftR :: CInt -> Int -> CInt Source # unsafeShiftR :: CInt -> Int -> CInt Source # rotateL :: CInt -> Int -> CInt Source # rotateR :: CInt -> Int -> CInt Source # popCount :: CInt -> Int Source #
Bits CUInt
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUInt -> CUInt -> CUInt Source # (.\|.) :: CUInt -> CUInt -> CUInt Source # xor :: CUInt -> CUInt -> CUInt Source # complement :: CUInt -> CUInt Source # shift :: CUInt -> Int -> CUInt Source # rotate :: CUInt -> Int -> CUInt Source # zeroBits :: CUInt Source # bit :: Int -> CUInt Source # setBit :: CUInt -> Int -> CUInt Source # clearBit :: CUInt -> Int -> CUInt Source # complementBit :: CUInt -> Int -> CUInt Source # testBit :: CUInt -> Int -> Bool Source # bitSizeMaybe :: CUInt -> Maybe Int Source # bitSize :: CUInt -> Int Source # isSigned :: CUInt -> Bool Source # shiftL :: CUInt -> Int -> CUInt Source # unsafeShiftL :: CUInt -> Int -> CUInt Source # shiftR :: CUInt -> Int -> CUInt Source # unsafeShiftR :: CUInt -> Int -> CUInt Source # rotateL :: CUInt -> Int -> CUInt Source # rotateR :: CUInt -> Int -> CUInt Source # popCount :: CUInt -> Int Source #
Bits CLong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CLong -> CLong -> CLong Source # (.\|.) :: CLong -> CLong -> CLong Source # xor :: CLong -> CLong -> CLong Source # complement :: CLong -> CLong Source # shift :: CLong -> Int -> CLong Source # rotate :: CLong -> Int -> CLong Source # zeroBits :: CLong Source # bit :: Int -> CLong Source # setBit :: CLong -> Int -> CLong Source # clearBit :: CLong -> Int -> CLong Source # complementBit :: CLong -> Int -> CLong Source # testBit :: CLong -> Int -> Bool Source # bitSizeMaybe :: CLong -> Maybe Int Source # bitSize :: CLong -> Int Source # isSigned :: CLong -> Bool Source # shiftL :: CLong -> Int -> CLong Source # unsafeShiftL :: CLong -> Int -> CLong Source # shiftR :: CLong -> Int -> CLong Source # unsafeShiftR :: CLong -> Int -> CLong Source # rotateL :: CLong -> Int -> CLong Source # rotateR :: CLong -> Int -> CLong Source # popCount :: CLong -> Int Source #
Bits CULong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CULong -> CULong -> CULong Source # (.\|.) :: CULong -> CULong -> CULong Source # xor :: CULong -> CULong -> CULong Source # complement :: CULong -> CULong Source # shift :: CULong -> Int -> CULong Source # rotate :: CULong -> Int -> CULong Source # zeroBits :: CULong Source # bit :: Int -> CULong Source # setBit :: CULong -> Int -> CULong Source # clearBit :: CULong -> Int -> CULong Source # complementBit :: CULong -> Int -> CULong Source # testBit :: CULong -> Int -> Bool Source # bitSizeMaybe :: CULong -> Maybe Int Source # bitSize :: CULong -> Int Source # isSigned :: CULong -> Bool Source # shiftL :: CULong -> Int -> CULong Source # unsafeShiftL :: CULong -> Int -> CULong Source # shiftR :: CULong -> Int -> CULong Source # unsafeShiftR :: CULong -> Int -> CULong Source # rotateL :: CULong -> Int -> CULong Source # rotateR :: CULong -> Int -> CULong Source # popCount :: CULong -> Int Source #
Bits CLLong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CLLong -> CLLong -> CLLong Source # (.\|.) :: CLLong -> CLLong -> CLLong Source # xor :: CLLong -> CLLong -> CLLong Source # complement :: CLLong -> CLLong Source # shift :: CLLong -> Int -> CLLong Source # rotate :: CLLong -> Int -> CLLong Source # zeroBits :: CLLong Source # bit :: Int -> CLLong Source # setBit :: CLLong -> Int -> CLLong Source # clearBit :: CLLong -> Int -> CLLong Source # complementBit :: CLLong -> Int -> CLLong Source # testBit :: CLLong -> Int -> Bool Source # bitSizeMaybe :: CLLong -> Maybe Int Source # bitSize :: CLLong -> Int Source # isSigned :: CLLong -> Bool Source # shiftL :: CLLong -> Int -> CLLong Source # unsafeShiftL :: CLLong -> Int -> CLLong Source # shiftR :: CLLong -> Int -> CLLong Source # unsafeShiftR :: CLLong -> Int -> CLLong Source # rotateL :: CLLong -> Int -> CLLong Source # rotateR :: CLLong -> Int -> CLLong Source # popCount :: CLLong -> Int Source #
Bits CULLong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CULLong -> CULLong -> CULLong Source # (.\|.) :: CULLong -> CULLong -> CULLong Source # xor :: CULLong -> CULLong -> CULLong Source # complement :: CULLong -> CULLong Source # shift :: CULLong -> Int -> CULLong Source # rotate :: CULLong -> Int -> CULLong Source # zeroBits :: CULLong Source # bit :: Int -> CULLong Source # setBit :: CULLong -> Int -> CULLong Source # clearBit :: CULLong -> Int -> CULLong Source # complementBit :: CULLong -> Int -> CULLong Source # testBit :: CULLong -> Int -> Bool Source # bitSizeMaybe :: CULLong -> Maybe Int Source # bitSize :: CULLong -> Int Source # isSigned :: CULLong -> Bool Source # shiftL :: CULLong -> Int -> CULLong Source # unsafeShiftL :: CULLong -> Int -> CULLong Source # shiftR :: CULLong -> Int -> CULLong Source # unsafeShiftR :: CULLong -> Int -> CULLong Source # rotateL :: CULLong -> Int -> CULLong Source # rotateR :: CULLong -> Int -> CULLong Source # popCount :: CULLong -> Int Source #
Bits CBool
Instance details Defined in Foreign.C.Types Methods (.&.) :: CBool -> CBool -> CBool Source # (.\|.) :: CBool -> CBool -> CBool Source # xor :: CBool -> CBool -> CBool Source # complement :: CBool -> CBool Source # shift :: CBool -> Int -> CBool Source # rotate :: CBool -> Int -> CBool Source # zeroBits :: CBool Source # bit :: Int -> CBool Source # setBit :: CBool -> Int -> CBool Source # clearBit :: CBool -> Int -> CBool Source # complementBit :: CBool -> Int -> CBool Source # testBit :: CBool -> Int -> Bool Source # bitSizeMaybe :: CBool -> Maybe Int Source # bitSize :: CBool -> Int Source # isSigned :: CBool -> Bool Source # shiftL :: CBool -> Int -> CBool Source # unsafeShiftL :: CBool -> Int -> CBool Source # shiftR :: CBool -> Int -> CBool Source # unsafeShiftR :: CBool -> Int -> CBool Source # rotateL :: CBool -> Int -> CBool Source # rotateR :: CBool -> Int -> CBool Source # popCount :: CBool -> Int Source #
Bits CPtrdiff
Instance details Defined in Foreign.C.Types Methods (.&.) :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # (.\|.) :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # xor :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # complement :: CPtrdiff -> CPtrdiff Source # shift :: CPtrdiff -> Int -> CPtrdiff Source # rotate :: CPtrdiff -> Int -> CPtrdiff Source # zeroBits :: CPtrdiff Source # bit :: Int -> CPtrdiff Source # setBit :: CPtrdiff -> Int -> CPtrdiff Source # clearBit :: CPtrdiff -> Int -> CPtrdiff Source # complementBit :: CPtrdiff -> Int -> CPtrdiff Source # testBit :: CPtrdiff -> Int -> Bool Source # bitSizeMaybe :: CPtrdiff -> Maybe Int Source # bitSize :: CPtrdiff -> Int Source # isSigned :: CPtrdiff -> Bool Source # shiftL :: CPtrdiff -> Int -> CPtrdiff Source # unsafeShiftL :: CPtrdiff -> Int -> CPtrdiff Source # shiftR :: CPtrdiff -> Int -> CPtrdiff Source # unsafeShiftR :: CPtrdiff -> Int -> CPtrdiff Source # rotateL :: CPtrdiff -> Int -> CPtrdiff Source # rotateR :: CPtrdiff -> Int -> CPtrdiff Source # popCount :: CPtrdiff -> Int Source #
Bits CSize
Instance details Defined in Foreign.C.Types Methods (.&.) :: CSize -> CSize -> CSize Source # (.\|.) :: CSize -> CSize -> CSize Source # xor :: CSize -> CSize -> CSize Source # complement :: CSize -> CSize Source # shift :: CSize -> Int -> CSize Source # rotate :: CSize -> Int -> CSize Source # zeroBits :: CSize Source # bit :: Int -> CSize Source # setBit :: CSize -> Int -> CSize Source # clearBit :: CSize -> Int -> CSize Source # complementBit :: CSize -> Int -> CSize Source # testBit :: CSize -> Int -> Bool Source # bitSizeMaybe :: CSize -> Maybe Int Source # bitSize :: CSize -> Int Source # isSigned :: CSize -> Bool Source # shiftL :: CSize -> Int -> CSize Source # unsafeShiftL :: CSize -> Int -> CSize Source # shiftR :: CSize -> Int -> CSize Source # unsafeShiftR :: CSize -> Int -> CSize Source # rotateL :: CSize -> Int -> CSize Source # rotateR :: CSize -> Int -> CSize Source # popCount :: CSize -> Int Source #
Bits CWchar
Instance details Defined in Foreign.C.Types Methods (.&.) :: CWchar -> CWchar -> CWchar Source # (.\|.) :: CWchar -> CWchar -> CWchar Source # xor :: CWchar -> CWchar -> CWchar Source # complement :: CWchar -> CWchar Source # shift :: CWchar -> Int -> CWchar Source # rotate :: CWchar -> Int -> CWchar Source # zeroBits :: CWchar Source # bit :: Int -> CWchar Source # setBit :: CWchar -> Int -> CWchar Source # clearBit :: CWchar -> Int -> CWchar Source # complementBit :: CWchar -> Int -> CWchar Source # testBit :: CWchar -> Int -> Bool Source # bitSizeMaybe :: CWchar -> Maybe Int Source # bitSize :: CWchar -> Int Source # isSigned :: CWchar -> Bool Source # shiftL :: CWchar -> Int -> CWchar Source # unsafeShiftL :: CWchar -> Int -> CWchar Source # shiftR :: CWchar -> Int -> CWchar Source # unsafeShiftR :: CWchar -> Int -> CWchar Source # rotateL :: CWchar -> Int -> CWchar Source # rotateR :: CWchar -> Int -> CWchar Source # popCount :: CWchar -> Int Source #
Bits CSigAtomic
Instance details Defined in Foreign.C.Types Methods (.&.) :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # (.\|.) :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # xor :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # complement :: CSigAtomic -> CSigAtomic Source # shift :: CSigAtomic -> Int -> CSigAtomic Source # rotate :: CSigAtomic -> Int -> CSigAtomic Source # zeroBits :: CSigAtomic Source # bit :: Int -> CSigAtomic Source # setBit :: CSigAtomic -> Int -> CSigAtomic Source # clearBit :: CSigAtomic -> Int -> CSigAtomic Source # complementBit :: CSigAtomic -> Int -> CSigAtomic Source # testBit :: CSigAtomic -> Int -> Bool Source # bitSizeMaybe :: CSigAtomic -> Maybe Int Source # bitSize :: CSigAtomic -> Int Source # isSigned :: CSigAtomic -> Bool Source # shiftL :: CSigAtomic -> Int -> CSigAtomic Source # unsafeShiftL :: CSigAtomic -> Int -> CSigAtomic Source # shiftR :: CSigAtomic -> Int -> CSigAtomic Source # unsafeShiftR :: CSigAtomic -> Int -> CSigAtomic Source # rotateL :: CSigAtomic -> Int -> CSigAtomic Source # rotateR :: CSigAtomic -> Int -> CSigAtomic Source # popCount :: CSigAtomic -> Int Source #
Bits CIntPtr
Instance details Defined in Foreign.C.Types Methods (.&.) :: CIntPtr -> CIntPtr -> CIntPtr Source # (.\|.) :: CIntPtr -> CIntPtr -> CIntPtr Source # xor :: CIntPtr -> CIntPtr -> CIntPtr Source # complement :: CIntPtr -> CIntPtr Source # shift :: CIntPtr -> Int -> CIntPtr Source # rotate :: CIntPtr -> Int -> CIntPtr Source # zeroBits :: CIntPtr Source # bit :: Int -> CIntPtr Source # setBit :: CIntPtr -> Int -> CIntPtr Source # clearBit :: CIntPtr -> Int -> CIntPtr Source # complementBit :: CIntPtr -> Int -> CIntPtr Source # testBit :: CIntPtr -> Int -> Bool Source # bitSizeMaybe :: CIntPtr -> Maybe Int Source # bitSize :: CIntPtr -> Int Source # isSigned :: CIntPtr -> Bool Source # shiftL :: CIntPtr -> Int -> CIntPtr Source # unsafeShiftL :: CIntPtr -> Int -> CIntPtr Source # shiftR :: CIntPtr -> Int -> CIntPtr Source # unsafeShiftR :: CIntPtr -> Int -> CIntPtr Source # rotateL :: CIntPtr -> Int -> CIntPtr Source # rotateR :: CIntPtr -> Int -> CIntPtr Source # popCount :: CIntPtr -> Int Source #
Bits CUIntPtr
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # (.\|.) :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # xor :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # complement :: CUIntPtr -> CUIntPtr Source # shift :: CUIntPtr -> Int -> CUIntPtr Source # rotate :: CUIntPtr -> Int -> CUIntPtr Source # zeroBits :: CUIntPtr Source # bit :: Int -> CUIntPtr Source # setBit :: CUIntPtr -> Int -> CUIntPtr Source # clearBit :: CUIntPtr -> Int -> CUIntPtr Source # complementBit :: CUIntPtr -> Int -> CUIntPtr Source # testBit :: CUIntPtr -> Int -> Bool Source # bitSizeMaybe :: CUIntPtr -> Maybe Int Source # bitSize :: CUIntPtr -> Int Source # isSigned :: CUIntPtr -> Bool Source # shiftL :: CUIntPtr -> Int -> CUIntPtr Source # unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr Source # shiftR :: CUIntPtr -> Int -> CUIntPtr Source # unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr Source # rotateL :: CUIntPtr -> Int -> CUIntPtr Source # rotateR :: CUIntPtr -> Int -> CUIntPtr Source # popCount :: CUIntPtr -> Int Source #
Bits CIntMax
Instance details Defined in Foreign.C.Types Methods (.&.) :: CIntMax -> CIntMax -> CIntMax Source # (.\|.) :: CIntMax -> CIntMax -> CIntMax Source # xor :: CIntMax -> CIntMax -> CIntMax Source # complement :: CIntMax -> CIntMax Source # shift :: CIntMax -> Int -> CIntMax Source # rotate :: CIntMax -> Int -> CIntMax Source # zeroBits :: CIntMax Source # bit :: Int -> CIntMax Source # setBit :: CIntMax -> Int -> CIntMax Source # clearBit :: CIntMax -> Int -> CIntMax Source # complementBit :: CIntMax -> Int -> CIntMax Source # testBit :: CIntMax -> Int -> Bool Source # bitSizeMaybe :: CIntMax -> Maybe Int Source # bitSize :: CIntMax -> Int Source # isSigned :: CIntMax -> Bool Source # shiftL :: CIntMax -> Int -> CIntMax Source # unsafeShiftL :: CIntMax -> Int -> CIntMax Source # shiftR :: CIntMax -> Int -> CIntMax Source # unsafeShiftR :: CIntMax -> Int -> CIntMax Source # rotateL :: CIntMax -> Int -> CIntMax Source # rotateR :: CIntMax -> Int -> CIntMax Source # popCount :: CIntMax -> Int Source #
Bits CUIntMax
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUIntMax -> CUIntMax -> CUIntMax Source # (.\|.) :: CUIntMax -> CUIntMax -> CUIntMax Source # xor :: CUIntMax -> CUIntMax -> CUIntMax Source # complement :: CUIntMax -> CUIntMax Source # shift :: CUIntMax -> Int -> CUIntMax Source # rotate :: CUIntMax -> Int -> CUIntMax Source # zeroBits :: CUIntMax Source # bit :: Int -> CUIntMax Source # setBit :: CUIntMax -> Int -> CUIntMax Source # clearBit :: CUIntMax -> Int -> CUIntMax Source # complementBit :: CUIntMax -> Int -> CUIntMax Source # testBit :: CUIntMax -> Int -> Bool Source # bitSizeMaybe :: CUIntMax -> Maybe Int Source # bitSize :: CUIntMax -> Int Source # isSigned :: CUIntMax -> Bool Source # shiftL :: CUIntMax -> Int -> CUIntMax Source # unsafeShiftL :: CUIntMax -> Int -> CUIntMax Source # shiftR :: CUIntMax -> Int -> CUIntMax Source # unsafeShiftR :: CUIntMax -> Int -> CUIntMax Source # rotateL :: CUIntMax -> Int -> CUIntMax Source # rotateR :: CUIntMax -> Int -> CUIntMax Source # popCount :: CUIntMax -> Int Source #
Bits WordPtr
Instance details Defined in Foreign.Ptr Methods (.&.) :: WordPtr -> WordPtr -> WordPtr Source # (.\|.) :: WordPtr -> WordPtr -> WordPtr Source # xor :: WordPtr -> WordPtr -> WordPtr Source # complement :: WordPtr -> WordPtr Source # shift :: WordPtr -> Int -> WordPtr Source # rotate :: WordPtr -> Int -> WordPtr Source # zeroBits :: WordPtr Source # bit :: Int -> WordPtr Source # setBit :: WordPtr -> Int -> WordPtr Source # clearBit :: WordPtr -> Int -> WordPtr Source # complementBit :: WordPtr -> Int -> WordPtr Source # testBit :: WordPtr -> Int -> Bool Source # bitSizeMaybe :: WordPtr -> Maybe Int Source # bitSize :: WordPtr -> Int Source # isSigned :: WordPtr -> Bool Source # shiftL :: WordPtr -> Int -> WordPtr Source # unsafeShiftL :: WordPtr -> Int -> WordPtr Source # shiftR :: WordPtr -> Int -> WordPtr Source # unsafeShiftR :: WordPtr -> Int -> WordPtr Source # rotateL :: WordPtr -> Int -> WordPtr Source # rotateR :: WordPtr -> Int -> WordPtr Source # popCount :: WordPtr -> Int Source #
Bits IntPtr
Instance details Defined in Foreign.Ptr Methods (.&.) :: IntPtr -> IntPtr -> IntPtr Source # (.\|.) :: IntPtr -> IntPtr -> IntPtr Source # xor :: IntPtr -> IntPtr -> IntPtr Source # complement :: IntPtr -> IntPtr Source # shift :: IntPtr -> Int -> IntPtr Source # rotate :: IntPtr -> Int -> IntPtr Source # zeroBits :: IntPtr Source # bit :: Int -> IntPtr Source # setBit :: IntPtr -> Int -> IntPtr Source # clearBit :: IntPtr -> Int -> IntPtr Source # complementBit :: IntPtr -> Int -> IntPtr Source # testBit :: IntPtr -> Int -> Bool Source # bitSizeMaybe :: IntPtr -> Maybe Int Source # bitSize :: IntPtr -> Int Source # isSigned :: IntPtr -> Bool Source # shiftL :: IntPtr -> Int -> IntPtr Source # unsafeShiftL :: IntPtr -> Int -> IntPtr Source # shiftR :: IntPtr -> Int -> IntPtr Source # unsafeShiftR :: IntPtr -> Int -> IntPtr Source # rotateL :: IntPtr -> Int -> IntPtr Source # rotateR :: IntPtr -> Int -> IntPtr Source # popCount :: IntPtr -> Int Source #
Bits Int54
Instance details Defined in Text.JSON.Canonical.Types Methods (.&.) :: Int54 -> Int54 -> Int54 Source # (.\|.) :: Int54 -> Int54 -> Int54 Source # xor :: Int54 -> Int54 -> Int54 Source # complement :: Int54 -> Int54 Source # shift :: Int54 -> Int -> Int54 Source # rotate :: Int54 -> Int -> Int54 Source # zeroBits :: Int54 Source # bit :: Int -> Int54 Source # setBit :: Int54 -> Int -> Int54 Source # clearBit :: Int54 -> Int -> Int54 Source # complementBit :: Int54 -> Int -> Int54 Source # testBit :: Int54 -> Int -> Bool Source # bitSizeMaybe :: Int54 -> Maybe Int Source # bitSize :: Int54 -> Int Source # isSigned :: Int54 -> Bool Source # shiftL :: Int54 -> Int -> Int54 Source # unsafeShiftL :: Int54 -> Int -> Int54 Source # shiftR :: Int54 -> Int -> Int54 Source # unsafeShiftR :: Int54 -> Int -> Int54 Source # rotateL :: Int54 -> Int -> Int54 Source # rotateR :: Int54 -> Int -> Int54 Source # popCount :: Int54 -> Int Source #
Bits a => Bits ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a Source # (.\|.) :: Identity a -> Identity a -> Identity a Source # xor :: Identity a -> Identity a -> Identity a Source # complement :: Identity a -> Identity a Source # shift :: Identity a -> Int -> Identity a Source # rotate :: Identity a -> Int -> Identity a Source # zeroBits :: Identity a Source # bit :: Int -> Identity a Source # setBit :: Identity a -> Int -> Identity a Source # clearBit :: Identity a -> Int -> Identity a Source # complementBit :: Identity a -> Int -> Identity a Source # testBit :: Identity a -> Int -> Bool Source # bitSizeMaybe :: Identity a -> Maybe Int Source # bitSize :: Identity a -> Int Source # isSigned :: Identity a -> Bool Source # shiftL :: Identity a -> Int -> Identity a Source # unsafeShiftL :: Identity a -> Int -> Identity a Source # shiftR :: Identity a -> Int -> Identity a Source # unsafeShiftR :: Identity a -> Int -> Identity a Source # rotateL :: Identity a -> Int -> Identity a Source # rotateR :: Identity a -> Int -> Identity a Source # popCount :: Identity a -> Int Source #
Bits a => Bits ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (.&.) :: Down a -> Down a -> Down a Source # (.\|.) :: Down a -> Down a -> Down a Source # xor :: Down a -> Down a -> Down a Source # complement :: Down a -> Down a Source # shift :: Down a -> Int -> Down a Source # rotate :: Down a -> Int -> Down a Source # zeroBits :: Down a Source # bit :: Int -> Down a Source # setBit :: Down a -> Int -> Down a Source # clearBit :: Down a -> Int -> Down a Source # complementBit :: Down a -> Int -> Down a Source # testBit :: Down a -> Int -> Bool Source # bitSizeMaybe :: Down a -> Maybe Int Source # bitSize :: Down a -> Int Source # isSigned :: Down a -> Bool Source # shiftL :: Down a -> Int -> Down a Source # unsafeShiftL :: Down a -> Int -> Down a Source # shiftR :: Down a -> Int -> Down a Source # unsafeShiftR :: Down a -> Int -> Down a Source # rotateL :: Down a -> Int -> Down a Source # rotateR :: Down a -> Int -> Down a Source # popCount :: Down a -> Int Source #
Bits a => Bits ( 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 Source # (.\|.) :: Const a b -> Const a b -> Const a b Source # xor :: Const a b -> Const a b -> Const a b Source # complement :: Const a b -> Const a b Source # shift :: Const a b -> Int -> Const a b Source # rotate :: Const a b -> Int -> Const a b Source # zeroBits :: Const a b Source # bit :: Int -> Const a b Source # setBit :: Const a b -> Int -> Const a b Source # clearBit :: Const a b -> Int -> Const a b Source # complementBit :: Const a b -> Int -> Const a b Source # testBit :: Const a b -> Int -> Bool Source # bitSizeMaybe :: Const a b -> Maybe Int Source # bitSize :: Const a b -> Int Source # isSigned :: Const a b -> Bool Source # shiftL :: Const a b -> Int -> Const a b Source # unsafeShiftL :: Const a b -> Int -> Const a b Source # shiftR :: Const a b -> Int -> Const a b Source # unsafeShiftR :: Const a b -> Int -> Const a b Source # rotateL :: Const a b -> Int -> Const a b Source # rotateR :: Const a b -> Int -> Const a b Source # popCount :: Const a b -> Int Source #
Bits a => Bits ( Tagged s a)
Instance details Defined in Data.Tagged Methods (.&.) :: Tagged s a -> Tagged s a -> Tagged s a Source # (.\|.) :: Tagged s a -> Tagged s a -> Tagged s a Source # xor :: Tagged s a -> Tagged s a -> Tagged s a Source # complement :: Tagged s a -> Tagged s a Source # shift :: Tagged s a -> Int -> Tagged s a Source # rotate :: Tagged s a -> Int -> Tagged s a Source # zeroBits :: Tagged s a Source # bit :: Int -> Tagged s a Source # setBit :: Tagged s a -> Int -> Tagged s a Source # clearBit :: Tagged s a -> Int -> Tagged s a Source # complementBit :: Tagged s a -> Int -> Tagged s a Source # testBit :: Tagged s a -> Int -> Bool Source # bitSizeMaybe :: Tagged s a -> Maybe Int Source # bitSize :: Tagged s a -> Int Source # isSigned :: Tagged s a -> Bool Source # shiftL :: Tagged s a -> Int -> Tagged s a Source # unsafeShiftL :: Tagged s a -> Int -> Tagged s a Source # shiftR :: Tagged s a -> Int -> Tagged s a Source # unsafeShiftR :: Tagged s a -> Int -> Tagged s a Source # rotateL :: Tagged s a -> Int -> Tagged s a Source # rotateR :: Tagged s a -> Int -> Tagged s a Source # popCount :: Tagged s a -> Int Source #

class Bits b => FiniteBits b where Source #

The FiniteBits class denotes types with a finite, fixed number of bits.

Since: base-4.7.0.0

Minimal complete definition

finiteBitSize

Methods

finiteBitSize :: b -> Int Source #

Return the number of bits in the type of the argument. The actual value of the argument is ignored. Moreover, finiteBitSize is total, in contrast to the deprecated bitSize function it replaces.

finiteBitSize = bitSize
bitSizeMaybe = Just . finiteBitSize

Since: base-4.7.0.0

countLeadingZeros :: b -> Int Source #

Count number of zero bits preceding the most significant set bit.

countLeadingZeros (zeroBits :: a) = finiteBitSize (zeroBits :: a)

countLeadingZeros can be used to compute log base 2 via

logBase2 x = finiteBitSize x - 1 - countLeadingZeros x

Note: The default implementation for this method is intentionally naive. However, the instances provided for the primitive integral types are implemented using CPU specific machine instructions.

Since: base-4.8.0.0

countTrailingZeros :: b -> Int Source #

Count number of zero bits following the least significant set bit.

countTrailingZeros (zeroBits :: a) = finiteBitSize (zeroBits :: a)
countTrailingZeros . negate = countTrailingZeros

The related find-first-set operation can be expressed in terms of countTrailingZeros as follows

findFirstSet x = 1 + countTrailingZeros x

Note: The default implementation for this method is intentionally naive. However, the instances provided for the primitive integral types are implemented using CPU specific machine instructions.

Since: base-4.8.0.0

Instances

Instances details

FiniteBits Bool	Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Bool -> Int Source # countLeadingZeros :: Bool -> Int Source # countTrailingZeros :: Bool -> Int Source #
FiniteBits Int	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Int -> Int Source # countLeadingZeros :: Int -> Int Source # countTrailingZeros :: Int -> Int Source #
FiniteBits Int8	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int8 -> Int Source # countLeadingZeros :: Int8 -> Int Source # countTrailingZeros :: Int8 -> Int Source #
FiniteBits Int16	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int16 -> Int Source # countLeadingZeros :: Int16 -> Int Source # countTrailingZeros :: Int16 -> Int Source #
FiniteBits Int32	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int32 -> Int Source # countLeadingZeros :: Int32 -> Int Source # countTrailingZeros :: Int32 -> Int Source #
FiniteBits Int64	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int64 -> Int Source # countLeadingZeros :: Int64 -> Int Source # countTrailingZeros :: Int64 -> Int Source #
FiniteBits Word	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Word -> Int Source # countLeadingZeros :: Word -> Int Source # countTrailingZeros :: Word -> Int Source #
FiniteBits Word8	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word8 -> Int Source # countLeadingZeros :: Word8 -> Int Source # countTrailingZeros :: Word8 -> Int Source #
FiniteBits Word16	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word16 -> Int Source # countLeadingZeros :: Word16 -> Int Source # countTrailingZeros :: Word16 -> Int Source #
FiniteBits Word32	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word32 -> Int Source # countLeadingZeros :: Word32 -> Int Source # countTrailingZeros :: Word32 -> Int Source #
FiniteBits Word64	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word64 -> Int Source # countLeadingZeros :: Word64 -> Int Source # countTrailingZeros :: Word64 -> Int Source #
FiniteBits CDev
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CDev -> Int Source # countLeadingZeros :: CDev -> Int Source # countTrailingZeros :: CDev -> Int Source #
FiniteBits CIno
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CIno -> Int Source # countLeadingZeros :: CIno -> Int Source # countTrailingZeros :: CIno -> Int Source #
FiniteBits CMode
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CMode -> Int Source # countLeadingZeros :: CMode -> Int Source # countTrailingZeros :: CMode -> Int Source #
FiniteBits COff
Instance details Defined in System.Posix.Types Methods finiteBitSize :: COff -> Int Source # countLeadingZeros :: COff -> Int Source # countTrailingZeros :: COff -> Int Source #
FiniteBits CPid
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CPid -> Int Source # countLeadingZeros :: CPid -> Int Source # countTrailingZeros :: CPid -> Int Source #
FiniteBits CSsize
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CSsize -> Int Source # countLeadingZeros :: CSsize -> Int Source # countTrailingZeros :: CSsize -> Int Source #
FiniteBits CGid
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CGid -> Int Source # countLeadingZeros :: CGid -> Int Source # countTrailingZeros :: CGid -> Int Source #
FiniteBits CNlink
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CNlink -> Int Source # countLeadingZeros :: CNlink -> Int Source # countTrailingZeros :: CNlink -> Int Source #
FiniteBits CUid
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CUid -> Int Source # countLeadingZeros :: CUid -> Int Source # countTrailingZeros :: CUid -> Int Source #
FiniteBits CTcflag
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CTcflag -> Int Source # countLeadingZeros :: CTcflag -> Int Source # countTrailingZeros :: CTcflag -> Int Source #
FiniteBits CRLim
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CRLim -> Int Source # countLeadingZeros :: CRLim -> Int Source # countTrailingZeros :: CRLim -> Int Source #
FiniteBits CBlkSize
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CBlkSize -> Int Source # countLeadingZeros :: CBlkSize -> Int Source # countTrailingZeros :: CBlkSize -> Int Source #
FiniteBits CBlkCnt
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CBlkCnt -> Int Source # countLeadingZeros :: CBlkCnt -> Int Source # countTrailingZeros :: CBlkCnt -> Int Source #
FiniteBits CClockId
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CClockId -> Int Source # countLeadingZeros :: CClockId -> Int Source # countTrailingZeros :: CClockId -> Int Source #
FiniteBits CFsBlkCnt
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CFsBlkCnt -> Int Source # countLeadingZeros :: CFsBlkCnt -> Int Source # countTrailingZeros :: CFsBlkCnt -> Int Source #
FiniteBits CFsFilCnt
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CFsFilCnt -> Int Source # countLeadingZeros :: CFsFilCnt -> Int Source # countTrailingZeros :: CFsFilCnt -> Int Source #
FiniteBits CId
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CId -> Int Source # countLeadingZeros :: CId -> Int Source # countTrailingZeros :: CId -> Int Source #
FiniteBits CKey
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CKey -> Int Source # countLeadingZeros :: CKey -> Int Source # countTrailingZeros :: CKey -> Int Source #
FiniteBits CSocklen
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CSocklen -> Int Source # countLeadingZeros :: CSocklen -> Int Source # countTrailingZeros :: CSocklen -> Int Source #
FiniteBits CNfds
Instance details Defined in System.Posix.Types Methods finiteBitSize :: CNfds -> Int Source # countLeadingZeros :: CNfds -> Int Source # countTrailingZeros :: CNfds -> Int Source #
FiniteBits Fd
Instance details Defined in System.Posix.Types Methods finiteBitSize :: Fd -> Int Source # countLeadingZeros :: Fd -> Int Source # countTrailingZeros :: Fd -> Int Source #
FiniteBits CChar
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CChar -> Int Source # countLeadingZeros :: CChar -> Int Source # countTrailingZeros :: CChar -> Int Source #
FiniteBits CSChar
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CSChar -> Int Source # countLeadingZeros :: CSChar -> Int Source # countTrailingZeros :: CSChar -> Int Source #
FiniteBits CUChar
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUChar -> Int Source # countLeadingZeros :: CUChar -> Int Source # countTrailingZeros :: CUChar -> Int Source #
FiniteBits CShort
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CShort -> Int Source # countLeadingZeros :: CShort -> Int Source # countTrailingZeros :: CShort -> Int Source #
FiniteBits CUShort
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUShort -> Int Source # countLeadingZeros :: CUShort -> Int Source # countTrailingZeros :: CUShort -> Int Source #
FiniteBits CInt
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CInt -> Int Source # countLeadingZeros :: CInt -> Int Source # countTrailingZeros :: CInt -> Int Source #
FiniteBits CUInt
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUInt -> Int Source # countLeadingZeros :: CUInt -> Int Source # countTrailingZeros :: CUInt -> Int Source #
FiniteBits CLong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CLong -> Int Source # countLeadingZeros :: CLong -> Int Source # countTrailingZeros :: CLong -> Int Source #
FiniteBits CULong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CULong -> Int Source # countLeadingZeros :: CULong -> Int Source # countTrailingZeros :: CULong -> Int Source #
FiniteBits CLLong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CLLong -> Int Source # countLeadingZeros :: CLLong -> Int Source # countTrailingZeros :: CLLong -> Int Source #
FiniteBits CULLong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CULLong -> Int Source # countLeadingZeros :: CULLong -> Int Source # countTrailingZeros :: CULLong -> Int Source #
FiniteBits CBool
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CBool -> Int Source # countLeadingZeros :: CBool -> Int Source # countTrailingZeros :: CBool -> Int Source #
FiniteBits CPtrdiff
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CPtrdiff -> Int Source # countLeadingZeros :: CPtrdiff -> Int Source # countTrailingZeros :: CPtrdiff -> Int Source #
FiniteBits CSize
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CSize -> Int Source # countLeadingZeros :: CSize -> Int Source # countTrailingZeros :: CSize -> Int Source #
FiniteBits CWchar
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CWchar -> Int Source # countLeadingZeros :: CWchar -> Int Source # countTrailingZeros :: CWchar -> Int Source #
FiniteBits CSigAtomic
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CSigAtomic -> Int Source # countLeadingZeros :: CSigAtomic -> Int Source # countTrailingZeros :: CSigAtomic -> Int Source #
FiniteBits CIntPtr
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CIntPtr -> Int Source # countLeadingZeros :: CIntPtr -> Int Source # countTrailingZeros :: CIntPtr -> Int Source #
FiniteBits CUIntPtr
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUIntPtr -> Int Source # countLeadingZeros :: CUIntPtr -> Int Source # countTrailingZeros :: CUIntPtr -> Int Source #
FiniteBits CIntMax
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CIntMax -> Int Source # countLeadingZeros :: CIntMax -> Int Source # countTrailingZeros :: CIntMax -> Int Source #
FiniteBits CUIntMax
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUIntMax -> Int Source # countLeadingZeros :: CUIntMax -> Int Source # countTrailingZeros :: CUIntMax -> Int Source #
FiniteBits WordPtr
Instance details Defined in Foreign.Ptr Methods finiteBitSize :: WordPtr -> Int Source # countLeadingZeros :: WordPtr -> Int Source # countTrailingZeros :: WordPtr -> Int Source #
FiniteBits IntPtr
Instance details Defined in Foreign.Ptr Methods finiteBitSize :: IntPtr -> Int Source # countLeadingZeros :: IntPtr -> Int Source # countTrailingZeros :: IntPtr -> Int Source #
FiniteBits Int54
Instance details Defined in Text.JSON.Canonical.Types Methods finiteBitSize :: Int54 -> Int Source # countLeadingZeros :: Int54 -> Int Source # countTrailingZeros :: Int54 -> Int Source #
FiniteBits a => FiniteBits ( Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int Source # countLeadingZeros :: Identity a -> Int Source # countTrailingZeros :: Identity a -> Int Source #
FiniteBits a => FiniteBits ( Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods finiteBitSize :: Down a -> Int Source # countLeadingZeros :: Down a -> Int Source # countTrailingZeros :: Down a -> Int Source #
FiniteBits a => FiniteBits ( Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int Source # countLeadingZeros :: Const a b -> Int Source # countTrailingZeros :: Const a b -> Int Source #
FiniteBits a => FiniteBits ( Tagged s a)
Instance details Defined in Data.Tagged Methods finiteBitSize :: Tagged s a -> Int Source # countLeadingZeros :: Tagged s a -> Int Source # countTrailingZeros :: Tagged s a -> Int Source #

integralEnumFromThenTo :: Integral a => a -> a -> a -> [a] Source #

integralEnumFromTo :: Integral a => a -> a -> [a] Source #

integralEnumFromThen :: ( Integral a, Bounded a) => a -> a -> [a] Source #

integralEnumFrom :: ( Integral a, Bounded a) => a -> [a] Source #

gcdWord' :: Word -> Word -> Word Source #

gcdInt' :: Int -> Int -> Int Source #

lcm :: Integral a => a -> a -> a Source #

lcm x y is the smallest positive integer that both x and y divide.

gcd :: Integral a => a -> a -> a Source #

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2 , gcd (-4) 6 = 2 , gcd 0 4 = 4 . gcd 0 0 = 0 . (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0 , the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound ) for such types.

(^^%^^) :: Integral a => Rational -> a -> Rational Source #

(^%^) :: Integral a => Rational -> a -> Rational Source #

(^^) :: ( Fractional a, Integral b) => a -> b -> a infixr 8 Source #

raise a number to an integral power

(^) :: ( Num a, Integral b) => a -> b -> a infixr 8 Source #

raise a number to a non-negative integral power

odd :: Integral a => a -> Bool Source #

even :: Integral a => a -> Bool Source #

numericEnumFromThenTo :: ( Ord a, Fractional a) => a -> a -> a -> [a] Source #

numericEnumFromTo :: ( Ord a, Fractional a) => a -> a -> [a] Source #

numericEnumFromThen :: Fractional a => a -> a -> [a] Source #

numericEnumFrom :: Fractional a => a -> [a] Source #

denominator :: Ratio a -> a Source #

Extract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

numerator :: Ratio a -> a Source #

Extract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

(%) :: Integral a => a -> a -> Ratio a infixl 7 Source #

Forms the ratio of two integral numbers.

reduce :: Integral a => a -> a -> Ratio a Source #

reduce is a subsidiary function used only in this module. It normalises a ratio by dividing both numerator and denominator by their greatest common divisor.

notANumber :: Rational Source #

infinity :: Rational Source #

ratioPrec1 :: Int Source #

ratioPrec :: Int Source #

underflowError :: a Source #

overflowError :: a Source #

ratioZeroDenominatorError :: a Source #

divZeroError :: a Source #

boundedEnumFromThen :: ( Enum a, Bounded a) => a -> a -> [a] Source #

boundedEnumFrom :: ( Enum a, Bounded a) => a -> [a] Source #

chr :: Int -> Char Source #

The toEnum method restricted to the type Char .

runST :: ( forall s. ST s a) -> a Source #

Return the value computed by a state thread. The forall ensures that the internal state used by the ST computation is inaccessible to the rest of the program.

intToDigit :: Int -> Char Source #

Convert an Int in the range 0 .. 15 to the corresponding single digit Char . This function fails on other inputs, and generates lower-case hexadecimal digits.

unzip :: [(a, b)] -> ([a], [b]) Source #

unzip transforms a list of pairs into a list of first components and a list of second components.

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] Source #

$\mathcal{O}(\min(m,n))$ . zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums:

>>> zipWith (+) [1, 2, 3] [4, 5, 6]
[5,7,9]

zipWith is right-lazy:

zipWith f [] _|_ = []

zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

reverse :: [a] -> [a] Source #

reverse xs returns the elements of xs in reverse order. xs must be finite.

break :: (a -> Bool ) -> [a] -> ([a], [a]) Source #

break , applied to a predicate p and a list xs , returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p and second element is the remainder of the list:

break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
break (< 9) [1,2,3] == ([],[1,2,3])
break (> 9) [1,2,3] == ([1,2,3],[])

break p is equivalent to span ( not . p) .

splitAt :: Int -> [a] -> ([a], [a]) Source #

splitAt n xs returns a tuple where first element is xs prefix of length n and second element is the remainder of the list:

splitAt 6 "Hello World!" == ("Hello ","World!")
splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
splitAt 1 [1,2,3] == ([1],[2,3])
splitAt 3 [1,2,3] == ([1,2,3],[])
splitAt 4 [1,2,3] == ([1,2,3],[])
splitAt 0 [1,2,3] == ([],[1,2,3])
splitAt (-1) [1,2,3] == ([],[1,2,3])

It is equivalent to ( take n xs, drop n xs) when n is not _|_ ( splitAt _|_ xs = _|_ ). splitAt is an instance of the more general genericSplitAt , in which n may be of any integral type.

drop :: Int -> [a] -> [a] Source #

drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs :

drop 6 "Hello World!" == "World!"
drop 3 [1,2,3,4,5] == [4,5]
drop 3 [1,2] == []
drop 3 [] == []
drop (-1) [1,2] == [1,2]
drop 0 [1,2] == [1,2]

It is an instance of the more general genericDrop , in which n may be of any integral type.

take :: Int -> [a] -> [a] Source #

take n , applied to a list xs , returns the prefix of xs of length n , or xs itself if n > length xs :

take 5 "Hello World!" == "Hello"
take 3 [1,2,3,4,5] == [1,2,3]
take 3 [1,2] == [1,2]
take 3 [] == []
take (-1) [1,2] == []
take 0 [1,2] == []

It is an instance of the more general genericTake , in which n may be of any integral type.

dropWhile :: (a -> Bool ) -> [a] -> [a] Source #

dropWhile p xs returns the suffix remaining after takeWhile p xs :

dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]

takeWhile :: (a -> Bool ) -> [a] -> [a] Source #

takeWhile , applied to a predicate p and a list xs , returns the longest prefix (possibly empty) of xs of elements that satisfy p :

takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []

cycle :: [a] -> [a] Source #

cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.

replicate :: Int -> a -> [a] Source #

replicate n x is a list of length n with x the value of every element. It is an instance of the more general genericReplicate , in which n may be of any integral type.

repeat :: a -> [a] Source #

repeat x is an infinite list, with x the value of every element.

iterate :: (a -> a) -> a -> [a] Source #

iterate f x returns an infinite list of repeated applications of f to x :

iterate f x == [x, f x, f (f x), ...]

Note that iterate is lazy, potentially leading to thunk build-up if the consumer doesn't force each iterate. See iterate' for a strict variant of this function.

scanr :: (a -> b -> b) -> b -> [a] -> [b] Source #

$\mathcal{O}(n)$ . scanr is the right-to-left dual of scanl . Note that

head (scanr f z xs) == foldr f z xs.

scanl' :: (b -> a -> b) -> b -> [a] -> [b] Source #

$\mathcal{O}(n)$ . A strictly accumulating version of scanl

scanl :: (b -> a -> b) -> b -> [a] -> [b] Source #

$\mathcal{O}(n)$ . scanl is similar to foldl , but returns a list of successive reduced values from the left:

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Note that

last (scanl f z xs) == foldl f z xs.

mapMaybe :: (a -> Maybe b) -> [a] -> [b] Source #

The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b . If this is Nothing , no element is added on to the result list. If it is Just b , then b is included in the result list.

Examples

Expand

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let readMaybeInt = readMaybe :: String -> Maybe Int
>>> mapMaybe readMaybeInt ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
[1,3]

If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3]
[1,2,3]

catMaybes :: [ Maybe a] -> [a] Source #

The catMaybes function takes a list of Maybe s and returns a list of all the Just values.

Examples

Expand

Basic usage:

>>> catMaybes [Just 1, Nothing, Just 3]
[1,3]

When constructing a list of Maybe values, catMaybes can be used to return all of the "success" results (if the list is the result of a map , then mapMaybe would be more appropriate):

>>> import Text.Read ( readMaybe )
>>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[Just 1,Nothing,Just 3]
>>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[1,3]

listToMaybe :: [a] -> Maybe a Source #

The listToMaybe function returns Nothing on an empty list or Just a where a is the first element of the list.

Examples

Expand

Basic usage:

>>> listToMaybe []
Nothing

>>> listToMaybe [9]
Just 9

>>> listToMaybe [1,2,3]
Just 1

Composing maybeToList with listToMaybe should be the identity on singleton/empty lists:

>>> maybeToList $ listToMaybe [5]
[5]
>>> maybeToList $ listToMaybe []
[]

But not on lists with more than one element:

>>> maybeToList $ listToMaybe [1,2,3]
[1]

maybeToList :: Maybe a -> [a] Source #

The maybeToList function returns an empty list when given Nothing or a singleton list when given Just .

Examples

Expand

Basic usage:

>>> maybeToList (Just 7)
[7]

>>> maybeToList Nothing
[]

One can use maybeToList to avoid pattern matching when combined with a function that (safely) works on lists:

>>> import Text.Read ( readMaybe )
>>> sum $ maybeToList (readMaybe "3")
3
>>> sum $ maybeToList (readMaybe "")
0

fromMaybe :: a -> Maybe a -> a Source #

The fromMaybe function takes a default value and and Maybe value. If the Maybe is Nothing , it returns the default values; otherwise, it returns the value contained in the Maybe .

Examples

Expand

Basic usage:

>>> fromMaybe "" (Just "Hello, World!")
"Hello, World!"

>>> fromMaybe "" Nothing
""

Read an integer from a string using readMaybe . If we fail to parse an integer, we want to return 0 by default:

>>> import Text.Read ( readMaybe )
>>> fromMaybe 0 (readMaybe "5")
5
>>> fromMaybe 0 (readMaybe "")
0

isNothing :: Maybe a -> Bool Source #

The isNothing function returns True iff its argument is Nothing .

Examples

Expand

Basic usage:

>>> isNothing (Just 3)
False

>>> isNothing (Just ())
False

>>> isNothing Nothing
True

Only the outer constructor is taken into consideration:

>>> isNothing (Just Nothing)
False

isJust :: Maybe a -> Bool Source #

The isJust function returns True iff its argument is of the form Just _ .

Examples

Expand

Basic usage:

>>> isJust (Just 3)
True

>>> isJust (Just ())
True

>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True

maybe :: b -> (a -> b) -> Maybe a -> b Source #

The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing , the function returns the default value. Otherwise, it applies the function to the value inside the Just and returns the result.

Examples

Expand

Basic usage:

>>> maybe False odd (Just 3)
True

>>> maybe False odd Nothing
False

Read an integer from a string using readMaybe . If we succeed, return twice the integer; that is, apply (*2) to it. If instead we fail to parse an integer, return 0 by default:

>>> import Text.Read ( readMaybe )
>>> maybe 0 (*2) (readMaybe "5")
10
>>> maybe 0 (*2) (readMaybe "")
0

Apply show to a Maybe Int . If we have Just n , we want to show the underlying Int n . But if we have Nothing , we return the empty string instead of (for example) "Nothing":

>>> maybe "" show (Just 5)
"5"
>>> maybe "" show Nothing
""

(&) :: a -> (a -> b) -> b infixl 1 Source #

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $ , which allows & to be nested in $ .

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 Source #

on b u x y runs the binary function b on the results of applying unary function u to two arguments x and y . From the opposite perspective, it transforms two inputs and combines the outputs.

((+) `on` f) x y = f x + f y

Typical usage: sortBy ( compare `on` fst ) .

Algebraic properties:

(*) `on` id = (*) -- (if (*) ∉ {⊥, const ⊥})

```
((*) `on` f) `on` g = (*) `on` (f . g)
```
```
flip on f . flip on g = flip on (g . f)
```

fix :: (a -> a) -> a Source #

fix f is the least fixed point of the function f , i.e. the least defined x such that f x = x .

For example, we can write the factorial function using direct recursion as

>>> let fac n = if n <= 1 then 1 else n * fac (n-1) in fac 5
120

This uses the fact that Haskell’s let introduces recursive bindings. We can rewrite this definition using fix ,

>>> fix (\rec n -> if n <= 1 then 1 else n * rec (n-1)) 5
120

Instead of making a recursive call, we introduce a dummy parameter rec ; when used within fix , this parameter then refers to fix ’s argument, hence the recursion is reintroduced.

void :: Functor f => f a -> f () Source #

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Using ApplicativeDo : ' void as ' can be understood as the do expression

do as
   pure ()

with an inferred Functor constraint.

Examples

Expand

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int () :

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

Replace every element of a list with unit:

>>> void [1,2,3]
[(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)
(1,())

Discard the result of an IO action:

>>> mapM print [1,2]
1
2
[(),()]
>>> void $ mapM print [1,2]
1
2

($>) :: Functor f => f a -> b -> f b infixl 4 Source #

Flipped version of <$ .

Using ApplicativeDo : ' as $> b ' can be understood as the do expression

do as
   pure b

with an inferred Functor constraint.

Examples

Expand

Replace the contents of a Maybe Int with a constant String :

>>> Nothing $> "foo"
Nothing
>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String , resulting in an Either Int String :

>>> Left 8675309 $> "foo"
Left 8675309
>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String :

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String :

>>> (1,2) $> "foo"
(1,"foo")

Since: base-4.7.0.0

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1 Source #

Flipped version of <$> .

(<&>) = flip fmap

Examples

Expand

Apply (+1) to a list, a Just and a Right :

>>> Just 2 <&> (+1)
Just 3

>>> [1,2,3] <&> (+1)
[2,3,4]

>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.0.0

swap :: (a, b) -> (b, a) Source #

Swap the components of a pair.

uncurry :: (a -> b -> c) -> (a, b) -> c Source #

uncurry converts a curried function to a function on pairs.

Examples

Expand

>>> uncurry (+) (1,2)
3

>>> uncurry ($) (show, 1)
"1"

>>> map (uncurry max) [(1,2), (3,4), (6,8)]
[2,4,8]

curry :: ((a, b) -> c) -> a -> b -> c Source #

curry converts an uncurried function to a curried function.

Examples

Expand

>>> curry fst 1 2
1

isEmptyMVar :: MVar a -> IO Bool Source #

Check whether a given MVar is empty.

Notice that the boolean value returned is just a snapshot of the state of the MVar. By the time you get to react on its result, the MVar may have been filled (or emptied) - so be extremely careful when using this operation. Use tryTakeMVar instead if possible.

tryReadMVar :: MVar a -> IO ( Maybe a) Source #

A non-blocking version of readMVar . The tryReadMVar function returns immediately, with Nothing if the MVar was empty, or Just a if the MVar was full with contents a .

Since: base-4.7.0.0

tryPutMVar :: MVar a -> a -> IO Bool Source #

A non-blocking version of putMVar . The tryPutMVar function attempts to put the value a into the MVar , returning True if it was successful, or False otherwise.

tryTakeMVar :: MVar a -> IO ( Maybe a) Source #

A non-blocking version of takeMVar . The tryTakeMVar function returns immediately, with Nothing if the MVar was empty, or Just a if the MVar was full with contents a . After tryTakeMVar , the MVar is left empty.

putMVar :: MVar a -> a -> IO () Source #

Put a value into an MVar . If the MVar is currently full, putMVar will wait until it becomes empty.

There are two further important properties of putMVar :

putMVar is single-wakeup. That is, if there are multiple threads blocked in putMVar , and the MVar becomes empty, only one thread will be woken up. The runtime guarantees that the woken thread completes its putMVar operation.
When multiple threads are blocked on an MVar , they are woken up in FIFO order. This is useful for providing fairness properties of abstractions built using MVar s.

readMVar :: MVar a -> IO a Source #

Atomically read the contents of an MVar . If the MVar is currently empty, readMVar will wait until it is full. readMVar is guaranteed to receive the next putMVar .

readMVar is multiple-wakeup, so when multiple readers are blocked on an MVar , all of them are woken up at the same time.

Compatibility note: Prior to base 4.7, readMVar was a combination of takeMVar and putMVar . This mean that in the presence of other threads attempting to putMVar , readMVar could block. Furthermore, readMVar would not receive the next putMVar if there was already a pending thread blocked on takeMVar . The old behavior can be recovered by implementing 'readMVar as follows:

 readMVar :: MVar a -> IO a
 readMVar m =
   mask_ $ do
     a <- takeMVar m
     putMVar m a
     return a

takeMVar :: MVar a -> IO a Source #

Return the contents of the MVar . If the MVar is currently empty, takeMVar will wait until it is full. After a takeMVar , the MVar is left empty.

There are two further important properties of takeMVar :

takeMVar is single-wakeup. That is, if there are multiple threads blocked in takeMVar , and the MVar becomes full, only one thread will be woken up. The runtime guarantees that the woken thread completes its takeMVar operation.
When multiple threads are blocked on an MVar , they are woken up in FIFO order. This is useful for providing fairness properties of abstractions built using MVar s.

newMVar :: a -> IO ( MVar a) Source #

Create an MVar which contains the supplied value.

newEmptyMVar :: IO ( MVar a) Source #

Create an MVar which is initially empty.

data MVar a Source #

An MVar (pronounced "em-var") is a synchronising variable, used for communication between concurrent threads. It can be thought of as a box, which may be empty or full.

Instances

Instances details

NFData1 MVar	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> MVar a -> () Source #
Eq ( MVar a)	Since: base-4.1.0.0
Instance details Defined in GHC.MVar Methods (==) :: MVar a -> MVar a -> Bool Source # (/=) :: MVar a -> MVar a -> Bool Source #
NFData ( MVar a)	NOTE : Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: MVar a -> () Source #

subtract :: Num a => a -> a -> a Source #

the same as flip ( - ) .

Because - is treated specially in the Haskell grammar, (- e ) is not a section, but an application of prefix negation. However, ( subtract exp ) is equivalent to the disallowed section.

currentCallStack :: IO [ String ] Source #

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

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

Since: base-4.5.0.0

asTypeOf :: a -> a -> a Source #

asTypeOf is a type-restricted version of const . It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.

until :: (a -> Bool ) -> (a -> a) -> a -> a Source #

until p f yields the result of applying f until p holds.

flip :: (a -> b -> c) -> b -> a -> c Source #

flip f takes its (first) two arguments in the reverse order of f .

>>> flip (++) "hello" "world"
"worldhello"

maxInt :: Int Source #

minInt :: Int Source #

ord :: Char -> Int Source #

The fromEnum method restricted to the type Char .

ap :: Monad m => m (a -> b) -> m a -> m b Source #

In many situations, the liftM operations can be replaced by uses of ap , which promotes function application.

return f `ap` x1 `ap` ... `ap` xn

is equivalent to

liftMn f x1 x2 ... xn

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2 ).

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2 ).

liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2 ).

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right. For example,

liftM2 (+) [0,1] [0,2] = [0,2,1,3]
liftM2 (+) (Just 1) Nothing = Nothing

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Source #

Promote a function to a monad.

when :: Applicative f => Bool -> f () -> f () Source #

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True , and otherwise do nothing.

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 Source #

Same as >>= , but with the arguments interchanged.

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d Source #

Lift a ternary function to actions.

Using ApplicativeDo : ' liftA3 f as bs cs ' can be understood as the do expression

do a <- as
   b <- bs
   c <- cs
   pure (f a b c)

liftA :: Applicative f => (a -> b) -> f a -> f b Source #

Lift a function to actions. This function may be used as a value for fmap in a Functor instance.

| Using ApplicativeDo : ' liftA f as ' can be understood as the do expression

do a <- as
   pure (f a)

with an inferred Functor constraint, weaker than Applicative .

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

A variant of <*> with the arguments reversed.

Using ApplicativeDo : ' as <**> fs ' can be understood as the do expression

do a <- as
   f <- fs
   pure (f a)

data NonEmpty a Source #

Non-empty (and non-strict) list type.

Since: base-4.9.0.0

Constructors

a :| [a] infixr 5

Instances

Instances details

Monad NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b Source # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source # return :: a -> NonEmpty a Source #
Functor NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b Source # (<$) :: a -> NonEmpty b -> NonEmpty a Source #
Applicative NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods pure :: a -> NonEmpty a Source # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source #
Foldable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m Source # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m Source # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m Source # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b Source # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b Source # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b Source # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b Source # foldr1 :: (a -> a -> a) -> NonEmpty a -> a Source # foldl1 :: (a -> a -> a) -> NonEmpty a -> a Source # toList :: NonEmpty a -> [a] Source # null :: NonEmpty a -> Bool Source # length :: NonEmpty a -> Int Source # elem :: Eq a => a -> NonEmpty a -> Bool Source # maximum :: Ord a => NonEmpty a -> a Source # minimum :: Ord a => NonEmpty a -> a Source # sum :: Num a => NonEmpty a -> a Source # product :: Num a => NonEmpty a -> a Source #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f ( NonEmpty b) Source # sequenceA :: Applicative f => NonEmpty (f a) -> f ( NonEmpty a) Source # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m ( NonEmpty b) Source # sequence :: Monad m => NonEmpty (m a) -> m ( NonEmpty a) Source #
NFData1 NonEmpty	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> NonEmpty a -> () Source #
Hashable1 NonEmpty	Since: hashable-1.3.1.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> NonEmpty a -> Int Source #
Lift a => Lift ( NonEmpty a :: Type )	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: NonEmpty a -> Q Exp Source # liftTyped :: NonEmpty a -> Q ( TExp ( NonEmpty a)) Source #
IsList ( NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Exts Associated Types type Item ( NonEmpty a) Source # Methods fromList :: [ Item ( NonEmpty a)] -> NonEmpty a Source # fromListN :: Int -> [ Item ( NonEmpty a)] -> NonEmpty a Source # toList :: NonEmpty a -> [ Item ( NonEmpty a)] Source #
Eq a => Eq ( NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (==) :: NonEmpty a -> NonEmpty a -> Bool Source # (/=) :: NonEmpty a -> NonEmpty a -> Bool Source #
Ord a => Ord ( NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering Source # (<) :: NonEmpty a -> NonEmpty a -> Bool Source # (<=) :: NonEmpty a -> NonEmpty a -> Bool Source # (>) :: NonEmpty a -> NonEmpty a -> Bool Source # (>=) :: NonEmpty a -> NonEmpty a -> Bool Source # max :: NonEmpty a -> NonEmpty a -> NonEmpty a Source # min :: NonEmpty a -> NonEmpty a -> NonEmpty a Source #
Read a => Read ( NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS ( NonEmpty a) Source # readList :: ReadS [ NonEmpty a] Source # readPrec :: ReadPrec ( NonEmpty a) Source # readListPrec :: ReadPrec [ NonEmpty a] Source #
Show a => Show ( NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS Source # show :: NonEmpty a -> String Source # showList :: [ NonEmpty a] -> ShowS Source #
Generic ( NonEmpty a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ( NonEmpty a) :: Type -> Type Source # Methods from :: NonEmpty a -> Rep ( NonEmpty a) x Source # to :: Rep ( NonEmpty a) x -> NonEmpty a Source #
Semigroup ( NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a Source # sconcat :: NonEmpty ( NonEmpty a) -> NonEmpty a Source # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a Source #
Hashable a => Hashable ( NonEmpty a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> NonEmpty a -> Int Source # hash :: NonEmpty a -> Int Source #
NFData a => NFData ( NonEmpty a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: NonEmpty a -> () Source #
Generic1 NonEmpty	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 NonEmpty :: k -> Type Source # Methods from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a Source # to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a Source #
type Rep ( NonEmpty a)
Instance details Defined in GHC.Generics type Rep ( NonEmpty a) = D1 (' MetaData "NonEmpty" "GHC.Base" "base" ' False ) ( C1 (' MetaCons ":\|" (' InfixI ' LeftAssociative 9) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 a) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 [a])))
type Item ( NonEmpty a)
Instance details Defined in GHC.Exts type Item ( NonEmpty a) = a
type Rep1 NonEmpty
Instance details Defined in GHC.Generics type Rep1 NonEmpty = D1 (' MetaData "NonEmpty" "GHC.Base" "base" ' False ) ( C1 (' MetaCons ":\|" (' InfixI ' LeftAssociative 9) ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) Par1 :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec1 [])))

getCallStack :: CallStack -> [([ Char ], SrcLoc )] Source #

Extract a list of call-sites from the CallStack .

The list is ordered by most recent call.

Since: base-4.8.1.0

type HasCallStack = ?callStack :: CallStack Source #

Request a CallStack.

NOTE: The implicit parameter ?callStack :: CallStack is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.9.0.0

stimesIdempotentMonoid :: ( Integral b, Monoid a) => b -> a -> a Source #

This is a valid definition of stimes for an idempotent Monoid .

When mappend x x = x , this definition should be preferred, because it works in $\mathcal{O}(1)$ rather than $\mathcal{O}(\log n)$

data SomeException Source #

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException .

Constructors

Exception e => SomeException e

Instances

Instances details

Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS Source # show :: SomeException -> String Source # showList :: [ SomeException ] -> ShowS Source #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException Source # fromException :: SomeException -> Maybe SomeException Source # displayException :: SomeException -> String Source #

(&&) :: Bool -> Bool -> Bool infixr 3 Source #

Boolean "and", lazy in the second argument

(||) :: Bool -> Bool -> Bool infixr 2 Source #

Boolean "or", lazy in the second argument

not :: Bool -> Bool Source #

Boolean "not"

data IntMap a Source #

A map of integers to values a .

Instances

Instances details

Functor IntMap
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> IntMap a -> IntMap b Source # (<$) :: a -> IntMap b -> IntMap a Source #
Foldable IntMap	Folds in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m Source # foldMap :: Monoid m => (a -> m) -> IntMap a -> m Source # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m Source # foldr :: (a -> b -> b) -> b -> IntMap a -> b Source # foldr' :: (a -> b -> b) -> b -> IntMap a -> b Source # foldl :: (b -> a -> b) -> b -> IntMap a -> b Source # foldl' :: (b -> a -> b) -> b -> IntMap a -> b Source # foldr1 :: (a -> a -> a) -> IntMap a -> a Source # foldl1 :: (a -> a -> a) -> IntMap a -> a Source # toList :: IntMap a -> [a] Source # null :: IntMap a -> Bool Source # length :: IntMap a -> Int Source # elem :: Eq a => a -> IntMap a -> Bool Source # maximum :: Ord a => IntMap a -> a Source # minimum :: Ord a => IntMap a -> a Source # sum :: Num a => IntMap a -> a Source # product :: Num a => IntMap a -> a Source #
Traversable IntMap	Traverses in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f ( IntMap b) Source # sequenceA :: Applicative f => IntMap (f a) -> f ( IntMap a) Source # mapM :: Monad m => (a -> m b) -> IntMap a -> m ( IntMap b) Source # sequence :: Monad m => IntMap (m a) -> m ( IntMap a) Source #
Eq1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftEq :: (a -> b -> Bool ) -> IntMap a -> IntMap b -> Bool Source #
Ord1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftCompare :: (a -> b -> Ordering ) -> IntMap a -> IntMap b -> Ordering Source #
Read1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftReadsPrec :: ( Int -> ReadS a) -> ReadS [a] -> Int -> ReadS ( IntMap a) Source # liftReadList :: ( Int -> ReadS a) -> ReadS [a] -> ReadS [ IntMap a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec ( IntMap a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ IntMap a] Source #
Show1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftShowsPrec :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> Int -> IntMap a -> ShowS Source # liftShowList :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> [ IntMap a] -> ShowS Source #
Hashable1 IntMap	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> IntMap a -> Int Source #
IsList ( IntMap a)	Since: containers-0.5.6.2
Instance details Defined in Data.IntMap.Internal Associated Types type Item ( IntMap a) Source # Methods fromList :: [ Item ( IntMap a)] -> IntMap a Source # fromListN :: Int -> [ Item ( IntMap a)] -> IntMap a Source # toList :: IntMap a -> [ Item ( IntMap a)] Source #
Eq a => Eq ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods (==) :: IntMap a -> IntMap a -> Bool Source # (/=) :: IntMap a -> IntMap a -> Bool Source #
Data a => Data ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> IntMap a -> c ( IntMap a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( IntMap a) Source # toConstr :: IntMap a -> Constr Source # dataTypeOf :: IntMap a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( IntMap a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( IntMap a)) Source # gmapT :: ( forall b. Data b => b -> b) -> IntMap a -> IntMap a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IntMap a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IntMap a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> IntMap a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> IntMap a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IntMap a -> m ( IntMap a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IntMap a -> m ( IntMap a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IntMap a -> m ( IntMap a) Source #
Ord a => Ord ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods compare :: IntMap a -> IntMap a -> Ordering Source # (<) :: IntMap a -> IntMap a -> Bool Source # (<=) :: IntMap a -> IntMap a -> Bool Source # (>) :: IntMap a -> IntMap a -> Bool Source # (>=) :: IntMap a -> IntMap a -> Bool Source # max :: IntMap a -> IntMap a -> IntMap a Source # min :: IntMap a -> IntMap a -> IntMap a Source #
Read e => Read ( IntMap e)
Instance details Defined in Data.IntMap.Internal Methods readsPrec :: Int -> ReadS ( IntMap e) Source # readList :: ReadS [ IntMap e] Source # readPrec :: ReadPrec ( IntMap e) Source # readListPrec :: ReadPrec [ IntMap e] Source #
Show a => Show ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods showsPrec :: Int -> IntMap a -> ShowS Source # show :: IntMap a -> String Source # showList :: [ IntMap a] -> ShowS Source #
Semigroup ( IntMap a)	Since: containers-0.5.7
Instance details Defined in Data.IntMap.Internal Methods (<>) :: IntMap a -> IntMap a -> IntMap a Source # sconcat :: NonEmpty ( IntMap a) -> IntMap a Source # stimes :: Integral b => b -> IntMap a -> IntMap a Source #
Monoid ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods mempty :: IntMap a Source # mappend :: IntMap a -> IntMap a -> IntMap a Source # mconcat :: [ IntMap a] -> IntMap a Source #
Hashable v => Hashable ( IntMap v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntMap v -> Int Source # hash :: IntMap v -> Int Source #
NFData a => NFData ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods rnf :: IntMap a -> () Source #
HeapWords a => HeapWords ( IntMap a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: IntMap a -> Int Source #
type Item ( IntMap a)
Instance details Defined in Data.IntMap.Internal type Item ( IntMap a) = ( Key , a)

data IntSet Source #

A set of integers.

Instances

Instances details

IsList IntSet	Since: containers-0.5.6.2
Instance details Defined in Data.IntSet.Internal Associated Types type Item IntSet Source # Methods fromList :: [ Item IntSet ] -> IntSet Source # fromListN :: Int -> [ Item IntSet ] -> IntSet Source # toList :: IntSet -> [ Item IntSet ] Source #
Eq IntSet
Instance details Defined in Data.IntSet.Internal Methods (==) :: IntSet -> IntSet -> Bool Source # (/=) :: IntSet -> IntSet -> Bool Source #
Data IntSet
Instance details Defined in Data.IntSet.Internal Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> IntSet -> c IntSet Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c IntSet Source # toConstr :: IntSet -> Constr Source # dataTypeOf :: IntSet -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c IntSet ) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c IntSet ) Source # gmapT :: ( forall b. Data b => b -> b) -> IntSet -> IntSet Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IntSet -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IntSet -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> IntSet -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> IntSet -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IntSet -> m IntSet Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IntSet -> m IntSet Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IntSet -> m IntSet Source #
Ord IntSet
Instance details Defined in Data.IntSet.Internal Methods compare :: IntSet -> IntSet -> Ordering Source # (<) :: IntSet -> IntSet -> Bool Source # (<=) :: IntSet -> IntSet -> Bool Source # (>) :: IntSet -> IntSet -> Bool Source # (>=) :: IntSet -> IntSet -> Bool Source # max :: IntSet -> IntSet -> IntSet Source # min :: IntSet -> IntSet -> IntSet Source #
Read IntSet
Instance details Defined in Data.IntSet.Internal Methods readsPrec :: Int -> ReadS IntSet Source # readList :: ReadS [ IntSet ] Source # readPrec :: ReadPrec IntSet Source # readListPrec :: ReadPrec [ IntSet ] Source #
Show IntSet
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> IntSet -> ShowS Source # show :: IntSet -> String Source # showList :: [ IntSet ] -> ShowS Source #
Semigroup IntSet	Since: containers-0.5.7
Instance details Defined in Data.IntSet.Internal Methods (<>) :: IntSet -> IntSet -> IntSet Source # sconcat :: NonEmpty IntSet -> IntSet Source # stimes :: Integral b => b -> IntSet -> IntSet Source #
Monoid IntSet
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet Source # mappend :: IntSet -> IntSet -> IntSet Source # mconcat :: [ IntSet ] -> IntSet Source #
Hashable IntSet	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntSet -> Int Source # hash :: IntSet -> Int Source #
NFData IntSet
Instance details Defined in Data.IntSet.Internal Methods rnf :: IntSet -> () Source #
HeapWords IntSet Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: IntSet -> Int Source #
type Item IntSet
Instance details Defined in Data.IntSet.Internal type Item IntSet = Key

data Seq a Source #

General-purpose finite sequences.

Instances

Instances details

Monad Seq
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b Source # (>>) :: Seq a -> Seq b -> Seq b Source # return :: a -> Seq a Source #
Functor Seq
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b Source # (<$) :: a -> Seq b -> Seq a Source #
MonadFix Seq	Since: containers-0.5.11
Instance details Defined in Data.Sequence.Internal Methods mfix :: (a -> Seq a) -> Seq a Source #
Applicative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a Source # (<>) :: Seq (a -> b) -> Seq a -> Seq b Source # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source # (>) :: Seq a -> Seq b -> Seq b Source # (<*) :: Seq a -> Seq b -> Seq a Source #
Foldable Seq
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m Source # foldMap :: Monoid m => (a -> m) -> Seq a -> m Source # foldMap' :: Monoid m => (a -> m) -> Seq a -> m Source # foldr :: (a -> b -> b) -> b -> Seq a -> b Source # foldr' :: (a -> b -> b) -> b -> Seq a -> b Source # foldl :: (b -> a -> b) -> b -> Seq a -> b Source # foldl' :: (b -> a -> b) -> b -> Seq a -> b Source # foldr1 :: (a -> a -> a) -> Seq a -> a Source # foldl1 :: (a -> a -> a) -> Seq a -> a Source # toList :: Seq a -> [a] Source # null :: Seq a -> Bool Source # length :: Seq a -> Int Source # elem :: Eq a => a -> Seq a -> Bool Source # maximum :: Ord a => Seq a -> a Source # minimum :: Ord a => Seq a -> a Source # sum :: Num a => Seq a -> a Source # product :: Num a => Seq a -> a Source #
Traversable Seq
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f ( Seq b) Source # sequenceA :: Applicative f => Seq (f a) -> f ( Seq a) Source # mapM :: Monad m => (a -> m b) -> Seq a -> m ( Seq b) Source # sequence :: Monad m => Seq (m a) -> m ( Seq a) Source #
Alternative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a Source # (<\|>) :: Seq a -> Seq a -> Seq a Source # some :: Seq a -> Seq [a] Source # many :: Seq a -> Seq [a] Source #
MonadPlus Seq
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a Source # mplus :: Seq a -> Seq a -> Seq a Source #
Eq1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftEq :: (a -> b -> Bool ) -> Seq a -> Seq b -> Bool Source #
Ord1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftCompare :: (a -> b -> Ordering ) -> Seq a -> Seq b -> Ordering Source #
Read1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftReadsPrec :: ( Int -> ReadS a) -> ReadS [a] -> Int -> ReadS ( Seq a) Source # liftReadList :: ( Int -> ReadS a) -> ReadS [a] -> ReadS [ Seq a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec ( Seq a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ Seq a] Source #
Show1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftShowsPrec :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> Int -> Seq a -> ShowS Source # liftShowList :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> [ Seq a] -> ShowS Source #
MonadZip Seq	`mzipWith` = `zipWith` `munzip` = `unzip`
Instance details Defined in Data.Sequence.Internal Methods mzip :: Seq a -> Seq b -> Seq (a, b) Source # mzipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source # munzip :: Seq (a, b) -> ( Seq a, Seq b) Source #
Hashable1 Seq	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Seq a -> Int Source #
UnzipWith Seq
Instance details Defined in Data.Sequence.Internal Methods unzipWith' :: (x -> (a, b)) -> Seq x -> ( Seq a, Seq b)
IsList ( Seq a)
Instance details Defined in Data.Sequence.Internal Associated Types type Item ( Seq a) Source # Methods fromList :: [ Item ( Seq a)] -> Seq a Source # fromListN :: Int -> [ Item ( Seq a)] -> Seq a Source # toList :: Seq a -> [ Item ( Seq a)] Source #
Eq a => Eq ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: Seq a -> Seq a -> Bool Source # (/=) :: Seq a -> Seq a -> Bool Source #
Data a => Data ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Seq a -> c ( Seq a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Seq a) Source # toConstr :: Seq a -> Constr Source # dataTypeOf :: Seq a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Seq a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Seq a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Seq a -> Seq a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Seq a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Seq a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Seq a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Seq a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Seq a -> m ( Seq a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Seq a -> m ( Seq a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Seq a -> m ( Seq a) Source #
Ord a => Ord ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods compare :: Seq a -> Seq a -> Ordering Source # (<) :: Seq a -> Seq a -> Bool Source # (<=) :: Seq a -> Seq a -> Bool Source # (>) :: Seq a -> Seq a -> Bool Source # (>=) :: Seq a -> Seq a -> Bool Source # max :: Seq a -> Seq a -> Seq a Source # min :: Seq a -> Seq a -> Seq a Source #
Read a => Read ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS ( Seq a) Source # readList :: ReadS [ Seq a] Source # readPrec :: ReadPrec ( Seq a) Source # readListPrec :: ReadPrec [ Seq a] Source #
Show a => Show ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS Source # show :: Seq a -> String Source # showList :: [ Seq a] -> ShowS Source #
a ~ Char => IsString ( Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq a Source #
Semigroup ( Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a Source # sconcat :: NonEmpty ( Seq a) -> Seq a Source # stimes :: Integral b => b -> Seq a -> Seq a Source #
Monoid ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a Source # mappend :: Seq a -> Seq a -> Seq a Source # mconcat :: [ Seq a] -> Seq a Source #
Hashable v => Hashable ( Seq v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Seq v -> Int Source # hash :: Seq v -> Int Source #
NFData a => NFData ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Seq a -> () Source #
HeapWords a => HeapWords ( Seq a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Seq a -> Int Source #
type Item ( Seq a)
Instance details Defined in Data.Sequence.Internal type Item ( Seq a) = a

data Set a Source #

A set of values a .

Instances

Instances details

Foldable Set	Folds in order of increasing key.
Instance details Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m Source # foldMap :: Monoid m => (a -> m) -> Set a -> m Source # foldMap' :: Monoid m => (a -> m) -> Set a -> m Source # foldr :: (a -> b -> b) -> b -> Set a -> b Source # foldr' :: (a -> b -> b) -> b -> Set a -> b Source # foldl :: (b -> a -> b) -> b -> Set a -> b Source # foldl' :: (b -> a -> b) -> b -> Set a -> b Source # foldr1 :: (a -> a -> a) -> Set a -> a Source # foldl1 :: (a -> a -> a) -> Set a -> a Source # toList :: Set a -> [a] Source # null :: Set a -> Bool Source # length :: Set a -> Int Source # elem :: Eq a => a -> Set a -> Bool Source # maximum :: Ord a => Set a -> a Source # minimum :: Ord a => Set a -> a Source # sum :: Num a => Set a -> a Source # product :: Num a => Set a -> a Source #
Eq1 Set	Since: containers-0.5.9
Instance details Defined in Data.Set.Internal Methods liftEq :: (a -> b -> Bool ) -> Set a -> Set b -> Bool Source #
Ord1 Set	Since: containers-0.5.9
Instance details Defined in Data.Set.Internal Methods liftCompare :: (a -> b -> Ordering ) -> Set a -> Set b -> Ordering Source #
Show1 Set	Since: containers-0.5.9
Instance details Defined in Data.Set.Internal Methods liftShowsPrec :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> Int -> Set a -> ShowS Source # liftShowList :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> [ Set a] -> ShowS Source #
Hashable1 Set	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: ( Int -> a -> Int ) -> Int -> Set a -> Int Source #
Ord a => IsList ( Set a)	Since: containers-0.5.6.2
Instance details Defined in Data.Set.Internal Associated Types type Item ( Set a) Source # Methods fromList :: [ Item ( Set a)] -> Set a Source # fromListN :: Int -> [ Item ( Set a)] -> Set a Source # toList :: Set a -> [ Item ( Set a)] Source #
Eq a => Eq ( Set a)
Instance details Defined in Data.Set.Internal Methods (==) :: Set a -> Set a -> Bool Source # (/=) :: Set a -> Set a -> Bool Source #
( Data a, Ord a) => Data ( Set a)
Instance details Defined in Data.Set.Internal Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Set a -> c ( Set a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Set a) Source # toConstr :: Set a -> Constr Source # dataTypeOf :: Set a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Set a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Set a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Set a -> Set a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Set a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Set a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Set a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Set a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Set a -> m ( Set a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Set a -> m ( Set a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Set a -> m ( Set a) Source #
Ord a => Ord ( Set a)
Instance details Defined in Data.Set.Internal Methods compare :: Set a -> Set a -> Ordering Source # (<) :: Set a -> Set a -> Bool Source # (<=) :: Set a -> Set a -> Bool Source # (>) :: Set a -> Set a -> Bool Source # (>=) :: Set a -> Set a -> Bool Source # max :: Set a -> Set a -> Set a Source # min :: Set a -> Set a -> Set a Source #
( Read a, Ord a) => Read ( Set a)
Instance details Defined in Data.Set.Internal Methods readsPrec :: Int -> ReadS ( Set a) Source # readList :: ReadS [ Set a] Source # readPrec :: ReadPrec ( Set a) Source # readListPrec :: ReadPrec [ Set a] Source #
Show a => Show ( Set a)
Instance details Defined in Data.Set.Internal Methods showsPrec :: Int -> Set a -> ShowS Source # show :: Set a -> String Source # showList :: [ Set a] -> ShowS Source #
Ord a => Semigroup ( Set a)	Since: containers-0.5.7
Instance details Defined in Data.Set.Internal Methods (<>) :: Set a -> Set a -> Set a Source # sconcat :: NonEmpty ( Set a) -> Set a Source # stimes :: Integral b => b -> Set a -> Set a Source #
Ord a => Monoid ( Set a)
Instance details Defined in Data.Set.Internal Methods mempty :: Set a Source # mappend :: Set a -> Set a -> Set a Source # mconcat :: [ Set a] -> Set a Source #
Hashable v => Hashable ( Set v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Set v -> Int Source # hash :: Set v -> Int Source #
NFData a => NFData ( Set a)
Instance details Defined in Data.Set.Internal Methods rnf :: Set a -> () Source #
HeapWords a => HeapWords ( Set a) Source #
Instance details Defined in Cardano.Prelude.HeapWords Methods heapWords :: Set a -> Int Source #
type Item ( Set a)
Instance details Defined in Data.Set.Internal type Item ( Set a) = a

force :: NFData a => a -> a Source #

a variant of deepseq that is useful in some circumstances:

force x = x `deepseq` x

force x fully evaluates x , and then returns it. Note that force x only performs evaluation when the value of force x itself is demanded, so essentially it turns shallow evaluation into deep evaluation.

force can be conveniently used in combination with ViewPatterns :

{-# LANGUAGE BangPatterns, ViewPatterns #-}
import Control.DeepSeq

someFun :: ComplexData -> SomeResult
someFun (force -> !arg) = {- 'arg' will be fully evaluated -}

Another useful application is to combine force with evaluate in order to force deep evaluation relative to other IO operations:

import Control.Exception (evaluate)
import Control.DeepSeq

main = do
  result <- evaluate $ force $ pureComputation
  {- 'result' will be fully evaluated at this point -}
  return ()

Finally, here's an exception safe variant of the readFile' example:

readFile' :: FilePath -> IO String
readFile' fn = bracket (openFile fn ReadMode) hClose $ \h ->
                       evaluate . force =<< hGetContents h

Since: deepseq-1.2.0.0

($!!) :: NFData a => (a -> b) -> a -> b infixr 0 Source #

the deep analogue of $! . In the expression f $!! x , x is fully evaluated before the function f is applied to it.

Since: deepseq-1.2.0.0

deepseq :: NFData a => a -> b -> b Source #

deepseq : fully evaluates the first argument, before returning the second.

The name deepseq is used to illustrate the relationship to seq : where seq is shallow in the sense that it only evaluates the top level of its argument, deepseq traverses the entire data structure evaluating it completely.

deepseq can be useful for forcing pending exceptions, eradicating space leaks, or forcing lazy I/O to happen. It is also useful in conjunction with parallel Strategies (see the parallel package).

There is no guarantee about the ordering of evaluation. The implementation may evaluate the components of the structure in any order or in parallel. To impose an actual order on evaluation, use pseq from Control.Parallel in the parallel package.

Since: deepseq-1.1.0.0

class NFData a where Source #

A class of types that can be fully evaluated.

Since: deepseq-1.1.0.0

Minimal complete definition

Nothing

Methods

rnf :: a -> () Source #

rnf should reduce its argument to normal form (that is, fully evaluate all sub-components), and then return () .

`Generic` `NFData` deriving

Starting with GHC 7.2, you can automatically derive instances for types possessing a Generic instance.

Note: Generic1 can be auto-derived starting with GHC 7.4

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic, Generic1)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, Generic1)

instance NFData a => NFData (Foo a)
instance NFData1 Foo

data Colour = Red | Green | Blue
              deriving Generic

instance NFData Colour

Starting with GHC 7.10, the example above can be written more concisely by enabling the new DeriveAnyClass extension:

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

import GHC.Generics (Generic)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, Generic1, NFData, NFData1)

data Colour = Red | Green | Blue
              deriving (Generic, NFData)

Compatibility with previous `deepseq` versions

Prior to version 1.4.0.0, the default implementation of the rnf method was defined as

rnf a = seq a ()

However, starting with deepseq-1.4.0.0 , the default implementation is based on DefaultSignatures allowing for more accurate auto-derived NFData instances. If you need the previously used exact default rnf method implementation semantics, use

instance NFData Colour where rnf x = seq x ()

or alternatively

instance NFData Colour where rnf = rwhnf

or

{-# LANGUAGE BangPatterns #-}
instance NFData Colour where rnf !_ = ()

Instances

Instances details

NFData Bool
Instance details Defined in Control.DeepSeq Methods rnf :: Bool -> () Source #
NFData Char
Instance details Defined in Control.DeepSeq Methods rnf :: Char -> () Source #
NFData Double
Instance details Defined in Control.DeepSeq Methods rnf :: Double -> () Source #
NFData Float
Instance details Defined in Control.DeepSeq Methods rnf :: Float -> () Source #
NFData Int
Instance details Defined in Control.DeepSeq Methods rnf :: Int -> () Source #
NFData Int8
Instance details Defined in Control.DeepSeq Methods rnf :: Int8 -> () Source #
NFData Int16
Instance details Defined in Control.DeepSeq Methods rnf :: Int16 -> () Source #
NFData Int32
Instance details Defined in Control.DeepSeq Methods rnf :: Int32 -> () Source #
NFData Int64
Instance details Defined in Control.DeepSeq Methods rnf :: Int64 -> () Source #
NFData Integer
Instance details Defined in Control.DeepSeq Methods rnf :: Integer -> () Source #
NFData Natural	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> () Source #
NFData Ordering
Instance details Defined in Control.DeepSeq Methods rnf :: Ordering -> () Source #
NFData Word
Instance details Defined in Control.DeepSeq Methods rnf :: Word -> () Source #
NFData Word8
Instance details Defined in Control.DeepSeq Methods rnf :: Word8 -> () Source #
NFData Word16
Instance details Defined in Control.DeepSeq Methods rnf :: Word16 -> () Source #
NFData Word32
Instance details Defined in Control.DeepSeq Methods rnf :: Word32 -> () Source #
NFData Word64
Instance details Defined in Control.DeepSeq Methods rnf :: Word64 -> () Source #
NFData CallStack	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: CallStack -> () Source #
NFData ()
Instance details Defined in Control.DeepSeq Methods rnf :: () -> () Source #
NFData TyCon	NOTE : Prior to `deepseq-1.4.4.0` this instance was only defined for `base-4.8.0.0` and later. Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: TyCon -> () Source #
NFData ByteString
Instance details Defined in Data.ByteString.Internal Methods rnf :: ByteString -> () Source #
NFData ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods rnf :: ByteString -> () Source #
NFData Scientific
Instance details Defined in Data.Scientific Methods rnf :: Scientific -> () Source #
NFData UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods rnf :: UTCTime -> () Source #
NFData JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: JSONPathElement -> () Source #
NFData Value
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Value -> () Source #
NFData Key
Instance details Defined in Data.Aeson.Key Methods rnf :: Key -> () Source #
NFData ThreadId	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ThreadId -> () Source #
NFData Void	Defined as `rnf = absurd` . Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Void -> () Source #
NFData Unique	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Unique -> () Source #
NFData Version	Since: deepseq-1.3.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Version -> () Source #
NFData ExitCode	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: ExitCode -> () Source #
NFData MaskingState	Since: deepseq-1.4.4.0
Instance details Defined in Control.DeepSeq Methods rnf :: MaskingState -> () Source #
NFData TypeRep	NOTE : Prior to `deepseq-1.4.4.0` this instance was only defined for `base-4.8.0.0` and later. Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: TypeRep -> () Source #
NFData All	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: All -> () Source #
NFData Any	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Any -> () Source #
NFData CChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CChar -> () Source #
NFData CSChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSChar -> () Source #
NFData CUChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUChar -> () Source #
NFData CShort	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CShort -> () Source #
NFData CUShort	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUShort -> () Source #
NFData CInt	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CInt -> () Source #
NFData CUInt	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUInt -> () Source #
NFData CLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CLong -> () Source #
NFData CULong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CULong -> () Source #
NFData CLLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CLLong -> () Source #
NFData CULLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CULLong -> () Source #
NFData CBool	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: CBool -> () Source #
NFData CFloat	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CFloat -> () Source #
NFData CDouble	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CDouble -> () Source #
NFData CPtrdiff	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CPtrdiff -> () Source #
NFData CSize	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSize -> () Source #
NFData CWchar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CWchar -> () Source #
NFData CSigAtomic	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSigAtomic -> () Source #
NFData CClock	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CClock -> () Source #
NFData CTime	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CTime -> () Source #
NFData CUSeconds	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUSeconds -> () Source #
NFData CSUSeconds	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSUSeconds -> () Source #
NFData CFile	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CFile -> () Source #
NFData CFpos	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CFpos -> () Source #
NFData CJmpBuf	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CJmpBuf -> () Source #
NFData CIntPtr	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CIntPtr -> () Source #
NFData CUIntPtr	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUIntPtr -> () Source #
NFData CIntMax	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CIntMax -> () Source #
NFData CUIntMax	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUIntMax -> () Source #
NFData Fingerprint	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Fingerprint -> () Source #
NFData SrcLoc	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: SrcLoc -> () Source #
NFData ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods rnf :: ShortByteString -> () Source #
NFData JSValue
Instance details Defined in Text.JSON.Canonical.Types Methods rnf :: JSValue -> () Source #
NFData JSString
Instance details Defined in Text.JSON.Canonical.Types Methods rnf :: JSString -> () Source #
NFData ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods rnf :: ByteArray -> () Source #
NFData IntSet
Instance details Defined in Data.IntSet.Internal Methods rnf :: IntSet -> () Source #
NFData DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods rnf :: DiffTime -> () Source #
NFData NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods rnf :: NominalDiffTime -> () Source #
NFData Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods rnf :: Doc -> () Source #
NFData TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods rnf :: TextDetails -> () Source #
NFData UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods rnf :: UnicodeException -> () Source #
NFData StdGen
Instance details Defined in System.Random.Internal Methods rnf :: StdGen -> () Source #
NFData ShortText
Instance details Defined in Data.Text.Short.Internal Methods rnf :: ShortText -> () Source #
NFData ZonedTime
Instance details Defined in Data.Time.LocalTime.Internal.ZonedTime Methods rnf :: ZonedTime -> () Source #
NFData LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods rnf :: LocalTime -> () Source #
NFData TimeOfDay
Instance details Defined in Data.Time.LocalTime.Internal.TimeOfDay Methods rnf :: TimeOfDay -> () Source #
NFData TimeZone
Instance details Defined in Data.Time.LocalTime.Internal.TimeZone Methods rnf :: TimeZone -> () Source #
NFData UniversalTime
Instance details Defined in Data.Time.Clock.Internal.UniversalTime Methods rnf :: UniversalTime -> () Source #
NFData Day
Instance details Defined in Data.Time.Calendar.Days Methods rnf :: Day -> () Source #
NFData UUID
Instance details Defined in Data.UUID.Types.Internal Methods rnf :: UUID -> () Source #
NFData a => NFData [a]
Instance details Defined in Control.DeepSeq Methods rnf :: [a] -> () Source #
NFData a => NFData ( Maybe a)
Instance details Defined in Control.DeepSeq Methods rnf :: Maybe a -> () Source #
NFData a => NFData ( Ratio a)
Instance details Defined in Control.DeepSeq Methods rnf :: Ratio a -> () Source #
NFData ( Ptr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Ptr a -> () Source #
NFData ( FunPtr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: FunPtr a -> () Source #
NFData a => NFData ( IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: IResult a -> () Source #
NFData a => NFData ( Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Result a -> () Source #
NFData v => NFData ( KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods rnf :: KeyMap v -> () Source #
NFData a => NFData ( Complex a)
Instance details Defined in Control.DeepSeq Methods rnf :: Complex a -> () Source #
NFData a => NFData ( Min a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Min a -> () Source #
NFData a => NFData ( Max a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Max a -> () Source #
NFData a => NFData ( First a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: First a -> () Source #
NFData a => NFData ( Last a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Last a -> () Source #
NFData m => NFData ( WrappedMonoid m)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: WrappedMonoid m -> () Source #
NFData a => NFData ( Option a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Option a -> () Source #
NFData ( StableName a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: StableName a -> () Source #
NFData a => NFData ( ZipList a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ZipList a -> () Source #
NFData a => NFData ( Identity a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Identity a -> () Source #
NFData ( IORef a)	NOTE : Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: IORef a -> () Source #
NFData a => NFData ( First a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: First a -> () Source #
NFData a => NFData ( Last a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Last a -> () Source #
NFData a => NFData ( Dual a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Dual a -> () Source #
NFData a => NFData ( Sum a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Sum a -> () Source #
NFData a => NFData ( Product a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Product a -> () Source #
NFData a => NFData ( Down a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Down a -> () Source #
NFData ( MVar a)	NOTE : Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: MVar a -> () Source #
NFData a => NFData ( NonEmpty a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: NonEmpty a -> () Source #
NFData a => NFData ( IntMap a)
Instance details Defined in Data.IntMap.Internal Methods rnf :: IntMap a -> () Source #
NFData a => NFData ( Tree a)
Instance details Defined in Data.Tree Methods rnf :: Tree a -> () Source #
NFData a => NFData ( Seq a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Seq a -> () Source #
NFData a => NFData ( FingerTree a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: FingerTree a -> () Source #
NFData a => NFData ( Digit a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Digit a -> () Source #
NFData a => NFData ( Node a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Node a -> () Source #
NFData a => NFData ( Elem a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Elem a -> () Source #
NFData a => NFData ( Set a)
Instance details Defined in Data.Set.Internal Methods rnf :: Set a -> () Source #
NFData1 f => NFData ( Fix f)
Instance details Defined in Data.Fix Methods rnf :: Fix f -> () Source #
NFData a => NFData ( DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods rnf :: DNonEmpty a -> () Source #
NFData a => NFData ( DList a)
Instance details Defined in Data.DList.Internal Methods rnf :: DList a -> () Source #
NFData a => NFData ( Hashed a)
Instance details Defined in Data.Hashable.Class Methods rnf :: Hashed a -> () Source #
NFData a => NFData ( Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods rnf :: Doc a -> () Source #
NFData a => NFData ( AnnotDetails a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods rnf :: AnnotDetails a -> () Source #
NFData ( PrimArray a)
Instance details Defined in Data.Primitive.PrimArray Methods rnf :: PrimArray a -> () Source #
NFData ( MutableByteArray s)
Instance details Defined in Data.Primitive.ByteArray Methods rnf :: MutableByteArray s -> () Source #
NFData a => NFData ( SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods rnf :: SmallArray a -> () Source #
NFData a => NFData ( Array a)
Instance details Defined in Data.Primitive.Array Methods rnf :: Array a -> () Source #
NFData g => NFData ( AtomicGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: AtomicGen g -> () Source #
NFData g => NFData ( IOGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: IOGen g -> () Source #
NFData g => NFData ( STGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: STGen g -> () Source #
NFData g => NFData ( TGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: TGen g -> () Source #
NFData g => NFData ( StateGen g)
Instance details Defined in System.Random.Internal Methods rnf :: StateGen g -> () Source #
NFData a => NFData ( Maybe a)
Instance details Defined in Data.Strict.Maybe Methods rnf :: Maybe a -> () Source #
NFData a => NFData ( HashSet a)
Instance details Defined in Data.HashSet.Internal Methods rnf :: HashSet a -> () Source #
NFData ( Vector a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () Source #
NFData ( Vector a)
Instance details Defined in Data.Vector.Storable Methods rnf :: Vector a -> () Source #
NFData ( Vector a)
Instance details Defined in Data.Vector.Primitive Methods rnf :: Vector a -> () Source #
NFData a => NFData ( Vector a)
Instance details Defined in Data.Vector Methods rnf :: Vector a -> () Source #
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) -> () Source #
( NFData a, NFData b) => NFData ( Either a b)
Instance details Defined in Control.DeepSeq Methods rnf :: Either a b -> () Source #
( NFData a, NFData b) => NFData (a, b)
Instance details Defined in Control.DeepSeq Methods rnf :: (a, b) -> () Source #
( NFData k, NFData a) => NFData ( Map k a)
Instance details Defined in Data.Map.Internal Methods rnf :: Map k a -> () Source #
( NFData k, NFData v) => NFData ( HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods rnf :: HashMap k v -> () Source #
( NFData a, NFData b) => NFData ( Array a b)
Instance details Defined in Control.DeepSeq Methods rnf :: Array a b -> () Source #
( NFData i, NFData r) => NFData ( IResult i r)
Instance details Defined in Data.Attoparsec.Internal.Types Methods rnf :: IResult i r -> () Source #
NFData ( Fixed a)	Since: deepseq-1.3.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Fixed a -> () Source #
( NFData a, NFData b) => NFData ( Arg a b)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Arg a b -> () Source #
NFData ( Proxy a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Proxy a -> () Source #
NFData ( STRef s a)	NOTE : Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: STRef s a -> () Source #
NFData ( MutablePrimArray s a)
Instance details Defined in Data.Primitive.PrimArray Methods rnf :: MutablePrimArray s a -> () Source #
( NFData a, NFData b) => NFData ( These a b)	Since: these-0.7.1
Instance details Defined in Data.These Methods rnf :: These a b -> () Source #
( NFData a, NFData b) => NFData ( Pair a b)
Instance details Defined in Data.Strict.Tuple Methods rnf :: Pair a b -> () Source #
( NFData a, NFData b) => NFData ( These a b)
Instance details Defined in Data.Strict.These Methods rnf :: These a b -> () Source #
( NFData a, NFData b) => NFData ( Either a b)
Instance details Defined in Data.Strict.Either Methods rnf :: Either a b -> () Source #
( NFData k, NFData v) => NFData ( Leaf k v)
Instance details Defined in Data.HashMap.Internal Methods rnf :: Leaf k v -> () Source #
NFData ( MVector s a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: MVector s a -> () Source #
NFData ( MVector s a)
Instance details Defined in Data.Vector.Primitive.Mutable Methods rnf :: MVector s a -> () Source #
( NFData a1, NFData a2, NFData a3) => NFData (a1, a2, a3)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3) -> () Source #
NFData a => NFData ( Const a b)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Const a b -> () Source #
NFData (a :~: b)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a :~: b) -> () Source #
NFData b => NFData ( Tagged s b)
Instance details Defined in Data.Tagged Methods rnf :: Tagged s b -> () Source #
( NFData1 f, NFData1 g, NFData a) => NFData ( These1 f g a)	This instance is available only with `deepseq >= 1.4.3.0`
Instance details Defined in Data.Functor.These Methods rnf :: These1 f g a -> () Source #
( NFData a1, NFData a2, NFData a3, NFData a4) => NFData (a1, a2, a3, a4)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4) -> () Source #
( NFData1 f, NFData1 g, NFData a) => NFData ( Product f g a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: Product f g a -> () Source #
( NFData1 f, NFData1 g, NFData a) => NFData ( Sum f g a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: Sum f g a -> () Source #
NFData (a :~~: b)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a :~~: b) -> () Source #
( NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5) -> () Source #
( NFData1 f, NFData1 g, NFData a) => NFData ( Compose f g a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: Compose f g a -> () Source #
( NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6) => NFData (a1, a2, a3, a4, a5, a6)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6) -> () Source #
( NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7) => NFData (a1, a2, a3, a4, a5, a6, a7)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6, a7) -> () Source #
( NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8) => NFData (a1, a2, a3, a4, a5, a6, a7, a8)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6, a7, a8) -> () Source #
( NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8, NFData a9) => NFData (a1, a2, a3, a4, a5, a6, a7, a8, a9)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> () Source #

lift :: ( MonadTrans t, Monad m) => m a -> t m a Source #

Lift a computation from the argument monad to the constructed monad.

gets :: MonadState s m => (s -> a) -> m a Source #

Gets specific component of the state, using a projection function supplied.

modify :: MonadState s m => (s -> s) -> m () Source #

Monadic state transformer.

Maps an old state to a new state inside a state monad. The old state is thrown away.

     Main> :t modify ((+1) :: Int -> Int)
     modify (...) :: (MonadState Int a) => a ()

This says that modify (+1) acts over any Monad that is a member of the MonadState class, with an Int state.

class Monad m => MonadState s (m :: Type -> Type ) | m -> s where Source #

Minimal definition is either both of get and put or just state

Minimal complete definition

state | get , put

Methods

get :: m s Source #

Return the state from the internals of the monad.

put :: s -> m () Source #

Replace the state inside the monad.

state :: (s -> (a, s)) -> m a Source #

Embed a simple state action into the monad.

Instances

Instances details

MonadState s m => MonadState s ( MaybeT m)
Instance details Defined in Control.Monad.State.Class Methods get :: MaybeT m s Source # put :: s -> MaybeT m () Source # state :: (s -> (a, s)) -> MaybeT m a Source #
MonadState s m => MonadState s ( ListT m)
Instance details Defined in Control.Monad.State.Class Methods get :: ListT m s Source # put :: s -> ListT m () Source # state :: (s -> (a, s)) -> ListT m a Source #
( Monoid w, MonadState s m) => MonadState s ( WriterT w m)
Instance details Defined in Control.Monad.State.Class Methods get :: WriterT w m s Source # put :: s -> WriterT w m () Source # state :: (s -> (a, s)) -> WriterT w m a Source #
( Monoid w, MonadState s m) => MonadState s ( WriterT w m)
Instance details Defined in Control.Monad.State.Class Methods get :: WriterT w m s Source # put :: s -> WriterT w m () Source # state :: (s -> (a, s)) -> WriterT w m a Source #
Monad m => MonadState s ( StateT s m)
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s Source # put :: s -> StateT s m () Source # state :: (s -> (a, s)) -> StateT s m a Source #
Monad m => MonadState s ( StateT s m)
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s Source # put :: s -> StateT s m () Source # state :: (s -> (a, s)) -> StateT s m a Source #
MonadState s m => MonadState s ( ReaderT r m)
Instance details Defined in Control.Monad.State.Class Methods get :: ReaderT r m s Source # put :: s -> ReaderT r m () Source # state :: (s -> (a, s)) -> ReaderT r m a Source #
MonadState s m => MonadState s ( IdentityT m)
Instance details Defined in Control.Monad.State.Class Methods get :: IdentityT m s Source # put :: s -> IdentityT m () Source # state :: (s -> (a, s)) -> IdentityT m a Source #
MonadState s m => MonadState s ( ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.State.Class Methods get :: ExceptT e m s Source # put :: s -> ExceptT e m () Source # state :: (s -> (a, s)) -> ExceptT e m a Source #
( Error e, MonadState s m) => MonadState s ( ErrorT e m)
Instance details Defined in Control.Monad.State.Class Methods get :: ErrorT e m s Source # put :: s -> ErrorT e m () Source # state :: (s -> (a, s)) -> ErrorT e m a Source #
MonadState s m => MonadState s ( ContT r m)
Instance details Defined in Control.Monad.State.Class Methods get :: ContT r m s Source # put :: s -> ContT r m () Source # state :: (s -> (a, s)) -> ContT r m a Source #
( Monad m, Monoid w) => MonadState s ( RWST r w s m)
Instance details Defined in Control.Monad.State.Class Methods get :: RWST r w s m s Source # put :: s -> RWST r w s m () Source # state :: (s -> (a, s)) -> RWST r w s m a Source #
( Monad m, Monoid w) => MonadState s ( RWST r w s m)
Instance details Defined in Control.Monad.State.Class Methods get :: RWST r w s m s Source # put :: s -> RWST r w s m () Source # state :: (s -> (a, s)) -> RWST r w s m a Source #

asks Source #

Arguments

:: MonadReader r m
=> (r -> a)	The selector function to apply to the environment.
-> m a

Retrieves a function of the current environment.

class Monad m => MonadReader r (m :: Type -> Type ) | m -> r where Source #

See examples in Control.Monad.Reader . Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

( ask | reader ), local

Methods

ask :: m r Source #

Retrieves the monad environment.

local Source #

Arguments

:: (r -> r)	The function to modify the environment.
-> m a	`Reader` to run in the modified environment.
-> m a

Executes a computation in a modified environment.

reader Source #

Arguments

:: (r -> a)	The selector function to apply to the environment.
-> m a

Retrieves a function of the current environment.

Instances

Instances details

MonadReader r m => MonadReader r ( MaybeT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: MaybeT m r Source # local :: (r -> r) -> MaybeT m a -> MaybeT m a Source # reader :: (r -> a) -> MaybeT m a Source #
MonadReader r m => MonadReader r ( ListT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ListT m r Source # local :: (r -> r) -> ListT m a -> ListT m a Source # reader :: (r -> a) -> ListT m a Source #
( Monoid w, MonadReader r m) => MonadReader r ( WriterT w m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r Source # local :: (r -> r) -> WriterT w m a -> WriterT w m a Source # reader :: (r -> a) -> WriterT w m a Source #
( Monoid w, MonadReader r m) => MonadReader r ( WriterT w m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r Source # local :: (r -> r) -> WriterT w m a -> WriterT w m a Source # reader :: (r -> a) -> WriterT w m a Source #
MonadReader r m => MonadReader r ( StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r Source # local :: (r -> r) -> StateT s m a -> StateT s m a Source # reader :: (r -> a) -> StateT s m a Source #
MonadReader r m => MonadReader r ( StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r Source # local :: (r -> r) -> StateT s m a -> StateT s m a Source # reader :: (r -> a) -> StateT s m a Source #
Monad m => MonadReader r ( ReaderT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ReaderT r m r Source # local :: (r -> r) -> ReaderT r m a -> ReaderT r m a Source # reader :: (r -> a) -> ReaderT r m a Source #
MonadReader r m => MonadReader r ( IdentityT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: IdentityT m r Source # local :: (r -> r) -> IdentityT m a -> IdentityT m a Source # reader :: (r -> a) -> IdentityT m a Source #
MonadReader r m => MonadReader r ( ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ExceptT e m r Source # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a Source # reader :: (r -> a) -> ExceptT e m a Source #
( Error e, MonadReader r m) => MonadReader r ( ErrorT e m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ErrorT e m r Source # local :: (r -> r) -> ErrorT e m a -> ErrorT e m a Source # reader :: (r -> a) -> ErrorT e m a Source #
MonadReader r ((->) r :: Type -> Type )
Instance details Defined in Control.Monad.Reader.Class Methods ask :: r -> r Source # local :: (r -> r) -> (r -> a) -> r -> a Source # reader :: (r -> a) -> r -> a Source #
MonadReader r' m => MonadReader r' ( ContT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ContT r m r' Source # local :: (r' -> r') -> ContT r m a -> ContT r m a Source # reader :: (r' -> a) -> ContT r m a Source #
( Monad m, Monoid w) => MonadReader r ( RWST r w s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: RWST r w s m r Source # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a Source # reader :: (r -> a) -> RWST r w s m a Source #
( Monad m, Monoid w) => MonadReader r ( RWST r w s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: RWST r w s m r Source # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a Source # reader :: (r -> a) -> RWST r w s m a Source #

class Monad m => MonadError e (m :: Type -> Type ) | m -> e where Source #

The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled.

Is parameterized over the type of error information and the monad type constructor. It is common to use Either String as the monad type constructor for an error monad in which error descriptions take the form of strings. In that case and many other common cases the resulting monad is already defined as an instance of the MonadError class. You can also define your own error type and/or use a monad type constructor other than Either String or Either IOError . In these cases you will have to explicitly define instances of the MonadError class. (If you are using the deprecated Control.Monad.Error or Control.Monad.Trans.Error , you may also have to define an Error instance.)

Methods

throwError :: e -> m a Source #

Is used within a monadic computation to begin exception processing.

catchError :: m a -> (e -> m a) -> m a Source #

A handler function to handle previous errors and return to normal execution. A common idiom is:

do { action1; action2; action3 } `catchError` handler

where the action functions can call throwError . Note that handler and the do-block must have the same return type.

Instances

Instances details

MonadError () Maybe	Since: mtl-2.2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: () -> Maybe a Source # catchError :: Maybe a -> (() -> Maybe a) -> Maybe a Source #
MonadError IOException IO
Instance details Defined in Control.Monad.Error.Class Methods throwError :: IOException -> IO a Source # catchError :: IO a -> ( IOException -> IO a) -> IO a Source #
MonadError e m => MonadError e ( MaybeT m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> MaybeT m a Source # catchError :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a Source #
MonadError e m => MonadError e ( ListT m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ListT m a Source # catchError :: ListT m a -> (e -> ListT m a) -> ListT m a Source #
MonadError e ( Either e)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> Either e a Source # catchError :: Either e a -> (e -> Either e a) -> Either e a Source #
( Monoid w, MonadError e m) => MonadError e ( WriterT w m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> WriterT w m a Source # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a Source #
( Monoid w, MonadError e m) => MonadError e ( WriterT w m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> WriterT w m a Source # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a Source #
MonadError e m => MonadError e ( StateT s m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> StateT s m a Source # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a Source #
MonadError e m => MonadError e ( StateT s m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> StateT s m a Source # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a Source #
MonadError e m => MonadError e ( ReaderT r m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ReaderT r m a Source # catchError :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a Source #
MonadError e m => MonadError e ( IdentityT m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> IdentityT m a Source # catchError :: IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a Source #
Monad m => MonadError e ( ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ExceptT e m a Source # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a Source #
( Monad m, Error e) => MonadError e ( ErrorT e m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ErrorT e m a Source # catchError :: ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a Source #
( Monoid w, MonadError e m) => MonadError e ( RWST r w s m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> RWST r w s m a Source # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a Source #
( Monoid w, MonadError e m) => MonadError e ( RWST r w s m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> RWST r w s m a Source # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a Source #

newtype ExceptT e (m :: Type -> Type ) a Source #

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

e - The exception type.
m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

Constructors

ExceptT (m ( Either e a))

Instances

Instances details

MonadState s m => MonadState s ( ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.State.Class Methods get :: ExceptT e m s Source # put :: s -> ExceptT e m () Source # state :: (s -> (a, s)) -> ExceptT e m a Source #
MonadReader r m => MonadReader r ( ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ExceptT e m r Source # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a Source # reader :: (r -> a) -> ExceptT e m a Source #
Monad m => MonadError e ( ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ExceptT e m a Source # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a Source #
MonadTrans ( ExceptT e)
Instance details Defined in Control.Monad.Trans.Except Methods lift :: Monad m => m a -> ExceptT e m a Source #
Monad m => Monad ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b Source # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b Source # return :: a -> ExceptT e m a Source #
Functor m => Functor ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b Source # (<$) :: a -> ExceptT e m b -> ExceptT e m a Source #
MonadFix m => MonadFix ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mfix :: (a -> ExceptT e m a) -> ExceptT e m a Source #
MonadFail m => MonadFail ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fail :: String -> ExceptT e m a Source #
( Functor m, Monad m) => Applicative ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods pure :: a -> ExceptT e m a Source # (<>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b Source # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c Source # (>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b Source # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a Source #
Foldable f => Foldable ( ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m Source # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m Source # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m Source # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b Source # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b Source # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b Source # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b Source # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a Source # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a Source # toList :: ExceptT e f a -> [a] Source # null :: ExceptT e f a -> Bool Source # length :: ExceptT e f a -> Int Source # elem :: Eq a => a -> ExceptT e f a -> Bool Source # maximum :: Ord a => ExceptT e f a -> a Source # minimum :: Ord a => ExceptT e f a -> a Source # sum :: Num a => ExceptT e f a -> a Source # product :: Num a => ExceptT e f a -> a Source #
Traversable f => Traversable ( ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods traverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 ( ExceptT e f b) Source # sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 ( ExceptT e f a) Source # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m ( ExceptT e f b) Source # sequence :: Monad m => ExceptT e f (m a) -> m ( ExceptT e f a) Source #
( Functor m, Monad m, Monoid e) => Alternative ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a Source # (<\|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source # some :: ExceptT e m a -> ExceptT e m [a] Source # many :: ExceptT e m a -> ExceptT e m [a] Source #
( Monad m, Monoid e) => MonadPlus ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a Source # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source #
Contravariant m => Contravariant ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods contramap :: (a -> b) -> ExceptT e m b -> ExceptT e m a Source # (>$) :: b -> ExceptT e m b -> ExceptT e m a Source #
( Eq e, Eq1 m) => Eq1 ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftEq :: (a -> b -> Bool ) -> ExceptT e m a -> ExceptT e m b -> Bool Source #
( Ord e, Ord1 m) => Ord1 ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftCompare :: (a -> b -> Ordering ) -> ExceptT e m a -> ExceptT e m b -> Ordering Source #
( Read e, Read1 m) => Read1 ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftReadsPrec :: ( Int -> ReadS a) -> ReadS [a] -> Int -> ReadS ( ExceptT e m a) Source # liftReadList :: ( Int -> ReadS a) -> ReadS [a] -> ReadS [ ExceptT e m a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec ( ExceptT e m a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ ExceptT e m a] Source #
( Show e, Show1 m) => Show1 ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftShowsPrec :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> Int -> ExceptT e m a -> ShowS Source # liftShowList :: ( Int -> a -> ShowS ) -> ([a] -> ShowS ) -> [ ExceptT e m a] -> ShowS Source #
MonadZip m => MonadZip ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzip :: ExceptT e m a -> ExceptT e m b -> ExceptT e m (a, b) Source # mzipWith :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c Source # munzip :: ExceptT e m (a, b) -> ( ExceptT e m a, ExceptT e m b) Source #
MonadIO m => MonadIO ( ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a Source #
PrimMonad m => PrimMonad ( ExceptT e m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState ( ExceptT e m) Source # Methods primitive :: ( State# ( PrimState ( ExceptT e m)) -> (# State# ( PrimState ( ExceptT e m)), a #)) -> ExceptT e m a Source #
( Eq e, Eq1 m, Eq a) => Eq ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool Source #
( Ord e, Ord1 m, Ord a) => Ord ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering Source # (<) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (>) :: ExceptT e m a -> ExceptT e m a -> Bool Source # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool Source # max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source # min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source #
( Read e, Read1 m, Read a) => Read ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods readsPrec :: Int -> ReadS ( ExceptT e m a) Source # readList :: ReadS [ ExceptT e m a] Source # readPrec :: ReadPrec ( ExceptT e m a) Source # readListPrec :: ReadPrec [ ExceptT e m a] Source #
( Show e, Show1 m, Show a) => Show ( ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods showsPrec :: Int -> ExceptT e m a -> ShowS Source # show :: ExceptT e m a -> String Source # showList :: [ ExceptT e m a] -> ShowS Source #
type PrimState ( ExceptT e m)
Instance details Defined in Control.Monad.Primitive type PrimState ( ExceptT e m) = PrimState m

type Except e = ExceptT e Identity Source #

The parameterizable exception monad.

Computations are either exceptions or normal values.

The return function returns a normal value, while >>= exits on the first exception. For a variant that continues after an error and collects all the errors, see Errors .

runExcept :: Except e a -> Either e a Source #

Extractor for computations in the exception monad. (The inverse of except ).

mapExcept :: ( Either e a -> Either e' b) -> Except e a -> Except e' b Source #

Map the unwrapped computation using the given function.

runExcept (mapExcept f m) = f (runExcept m)

withExcept :: (e -> e') -> Except e a -> Except e' a Source #

Transform any exceptions thrown by the computation using the given function (a specialization of withExceptT ).

runExceptT :: ExceptT e m a -> m ( Either e a) Source #

The inverse of ExceptT .

mapExceptT :: (m ( Either e a) -> n ( Either e' b)) -> ExceptT e m a -> ExceptT e' n b Source #

Map the unwrapped computation using the given function.

runExceptT (mapExceptT f m) = f (runExceptT m)

withExceptT :: forall (m :: Type -> Type ) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a Source #

Transform any exceptions thrown by the computation using the given function.

newtype ReaderT r (m :: Type -> Type ) a Source #

The reader monad transformer, which adds a read-only environment to the given monad.

The return function ignores the environment, while >>= passes the inherited environment to both subcomputations.

Constructors

ReaderT
Fields runReaderT :: r -> m a

Instances

Instances details

MonadState s m => MonadState s ( ReaderT r m)
Instance details Defined in Control.Monad.State.Class Methods get :: ReaderT r m s Source # put :: s -> ReaderT r m () Source # state :: (s -> (a, s)) -> ReaderT r m a Source #
Monad m => MonadReader r ( ReaderT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ReaderT r m r Source # local :: (r -> r) -> ReaderT r m a -> ReaderT r m a Source # reader :: (r -> a) -> ReaderT r m a Source #
MonadError e m => MonadError e ( ReaderT r m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ReaderT r m a Source # catchError :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a Source #
MonadTrans ( ReaderT r)
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a Source #
Monad m => Monad ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b Source # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b Source # return :: a -> ReaderT r m a Source #
Functor m => Functor ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b Source # (<$) :: a -> ReaderT r m b -> ReaderT r m a Source #
MonadFix m => MonadFix ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mfix :: (a -> ReaderT r m a) -> ReaderT r m a Source #
MonadFail m => MonadFail ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fail :: String -> ReaderT r m a Source #
Applicative m => Applicative ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods pure :: a -> ReaderT r m a Source # (<>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b Source # liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c Source # (>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b Source # (<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a Source #
Alternative m => Alternative ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a Source # (<\|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a Source # some :: ReaderT r m a -> ReaderT r m [a] Source # many :: ReaderT r m a -> ReaderT r m [a] Source #
MonadPlus m => MonadPlus ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a Source # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a Source #
Contravariant m => Contravariant ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods contramap :: (a -> b) -> ReaderT r m b -> ReaderT r m a Source # (>$) :: b -> ReaderT r m b -> ReaderT r m a Source #
MonadZip m => MonadZip ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzip :: ReaderT r m a -> ReaderT r m b -> ReaderT r m (a, b) Source # mzipWith :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c Source # munzip :: ReaderT r m (a, b) -> ( ReaderT r m a, ReaderT r m b) Source #
MonadIO m => MonadIO ( ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a Source #
PrimMonad m => PrimMonad ( ReaderT r m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState ( ReaderT r m) Source # Methods primitive :: ( State# ( PrimState ( ReaderT r m)) -> (# State# ( PrimState ( ReaderT r m)), a #)) -> ReaderT r m a Source #
type PrimState ( ReaderT r m)
Instance details Defined in Control.Monad.Primitive type PrimState ( ReaderT r m) = PrimState m

type Reader r = ReaderT r Identity Source #

The parameterizable reader monad.

Computations are functions of a shared environment.

The return function ignores the environment, while >>= passes the inherited environment to both subcomputations.

runReader Source #

Arguments

:: Reader r a	A `Reader` to run.
-> r	An initial environment.
-> a

Runs a Reader and extracts the final value from it. (The inverse of reader .)

newtype StateT s (m :: Type -> Type ) a Source #

A state transformer monad parameterized by:

s - The state.
m - The inner monad.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

Constructors

StateT
Fields runStateT :: s -> m (a, s)

Instances

Instances details

Monad m => MonadState s ( StateT s m)
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s Source # put :: s -> StateT s m () Source # state :: (s -> (a, s)) -> StateT s m a Source #
MonadReader r m => MonadReader r ( StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r Source # local :: (r -> r) -> StateT s m a -> StateT s m a Source # reader :: (r -> a) -> StateT s m a Source #
MonadError e m => MonadError e ( StateT s m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> StateT s m a Source # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a Source #
MonadTrans ( StateT s)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods lift :: Monad m => m a -> StateT s m a Source #
Monad m => Monad ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b Source # (>>) :: StateT s m a -> StateT s m b -> StateT s m b Source # return :: a -> StateT s m a Source #
Functor m => Functor ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b Source # (<$) :: a -> StateT s m b -> StateT s m a Source #
MonadFix m => MonadFix ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mfix :: (a -> StateT s m a) -> StateT s m a Source #
MonadFail m => MonadFail ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fail :: String -> StateT s m a Source #
( Functor m, Monad m) => Applicative ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods pure :: a -> StateT s m a Source # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c Source # (>) :: StateT s m a -> StateT s m b -> StateT s m b Source # (<*) :: StateT s m a -> StateT s m b -> StateT s m a Source #
( Functor m, MonadPlus m) => Alternative ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods empty :: StateT s m a Source # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a Source # some :: StateT s m a -> StateT s m [a] Source # many :: StateT s m a -> StateT s m [a] Source #
MonadPlus m => MonadPlus ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a Source # mplus :: StateT s m a -> StateT s m a -> StateT s m a Source #
Contravariant m => Contravariant ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods contramap :: (a -> b) -> StateT s m b -> StateT s m a Source # (>$) :: b -> StateT s m b -> StateT s m a Source #
MonadIO m => MonadIO ( StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a Source #
PrimMonad m => PrimMonad ( StateT s m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState ( StateT s m) Source # Methods primitive :: ( State# ( PrimState ( StateT s m)) -> (# State# ( PrimState ( StateT s m)), a #)) -> StateT s m a Source #
type PrimState ( StateT s m)
Instance details Defined in Control.Monad.Primitive type PrimState ( StateT s m) = PrimState m

type State s = StateT s Identity Source #

A state monad parameterized by the type s of the state to carry.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

runState Source #

Arguments

:: State s a	state-passing computation to execute
-> s	initial state
-> (a, s)	return value and final state

Unwrap a state monad computation as a function. (The inverse of state .)

evalState Source #

Arguments

:: State s a	state-passing computation to execute
-> s	initial value
-> a	return value of the state computation

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

```
evalState m s = fst (runState m s)
```

execState Source #

Arguments

:: State s a	state-passing computation to execute
-> s	initial value
-> s	final state

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

```
execState m s = snd (runState m s)
```

withState :: (s -> s) -> State s a -> State s a Source #

withState f m executes action m on a state modified by applying f .

```
withState f m = modify f >> m
```

evalStateT :: Monad m => StateT s m a -> s -> m a Source #

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

evalStateT m s = liftM fst (runStateT m s)

execStateT :: Monad m => StateT s m a -> s -> m s Source #

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

execStateT m s = liftM snd (runStateT m s)

die :: Text -> IO a Source #

Terminate main process with failure

show :: ( Show a, ConvertText String b) => a -> b Source #

liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c Source #

Lift an IO operation with 2 arguments into another monad

liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b Source #

Lift an IO operation with 1 argument into another monad

guardedA :: ( Functor f, Alternative t) => (a -> f Bool ) -> a -> f (t a) Source #

guarded :: Alternative f => (a -> Bool ) -> a -> f a Source #

pass :: Applicative f => f () Source #

Do nothing returning unit inside applicative.

throwTo :: ( MonadIO m, Exception e) => ThreadId -> e -> m () Source #

Lifted throwTo

throwIO :: ( MonadIO m, Exception e) => e -> m a Source #

Lifted throwIO

print :: ( MonadIO m, Show a) => a -> m () Source #

The print function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class Show; print converts values to strings for output using the show operation and adds a newline.

applyN :: Int -> (a -> a) -> a -> a Source #

Apply a function n times to a given value

unsnoc :: [x] -> Maybe ([x], x) Source #

uncons :: [a] -> Maybe (a, [a]) Source #

map :: Functor f => (a -> b) -> f a -> f b Source #

type LText = Text Source #

type LByteString = ByteString Source #

undefined :: a Source #

notImplemented :: a Source #

traceId :: Text -> Text Source #

traceM :: Monad m => Text -> m () Source #

traceShowM :: ( Show a, Monad m) => a -> m () Source #

traceShowId :: Show a => a -> a Source #

traceShow :: Show a => a -> b -> b Source #

traceIO :: Print b => b -> a -> IO a Source #

trace :: Print b => b -> a -> a Source #

putErrText :: MonadIO m => Text -> m () Source #

putLByteString :: MonadIO m => ByteString -> m () Source #

putByteString :: MonadIO m => ByteString -> m () Source #

putLText :: MonadIO m => Text -> m () Source #

putText :: MonadIO m => Text -> m () Source #

class Print a where Source #

Minimal complete definition

hPutStr , hPutStrLn

Methods

hPutStr :: MonadIO m => Handle -> a -> m () Source #

putStr :: MonadIO m => a -> m () Source #

hPutStrLn :: MonadIO m => Handle -> a -> m () Source #

putStrLn :: MonadIO m => a -> m () Source #

putErrLn :: MonadIO m => a -> m () Source #

Instances

Instances details

Print ByteString
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> ByteString -> m () Source # putStr :: MonadIO m => ByteString -> m () Source # hPutStrLn :: MonadIO m => Handle -> ByteString -> m () Source # putStrLn :: MonadIO m => ByteString -> m () Source # putErrLn :: MonadIO m => ByteString -> m () Source #
Print ByteString
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> ByteString -> m () Source # putStr :: MonadIO m => ByteString -> m () Source # hPutStrLn :: MonadIO m => Handle -> ByteString -> m () Source # putStrLn :: MonadIO m => ByteString -> m () Source # putErrLn :: MonadIO m => ByteString -> m () Source #
Print Text
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> Text -> m () Source # putStr :: MonadIO m => Text -> m () Source # hPutStrLn :: MonadIO m => Handle -> Text -> m () Source # putStrLn :: MonadIO m => Text -> m () Source # putErrLn :: MonadIO m => Text -> m () Source #
Print Text
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> Text -> m () Source # putStr :: MonadIO m => Text -> m () Source # hPutStrLn :: MonadIO m => Handle -> Text -> m () Source # putStrLn :: MonadIO m => Text -> m () Source # putErrLn :: MonadIO m => Text -> m () Source #
Print [ Char ]
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> [ Char ] -> m () Source # putStr :: MonadIO m => [ Char ] -> m () Source # hPutStrLn :: MonadIO m => Handle -> [ Char ] -> m () Source # putStrLn :: MonadIO m => [ Char ] -> m () Source # putErrLn :: MonadIO m => [ Char ] -> m () Source #

zero :: Monoid m => m Source #

Alias for mempty

class Monoid m => Semiring m where Source #

Methods

one :: m Source #

(<.>) :: m -> m -> m Source #

atDef :: a -> [a] -> Int -> a Source #

atMay :: [a] -> Int -> Maybe a Source #

foldl1May' :: (a -> a -> a) -> [a] -> Maybe a Source #

foldl1May :: (a -> a -> a) -> [a] -> Maybe a Source #

foldr1May :: (a -> a -> a) -> [a] -> Maybe a Source #

maximumDef :: Ord a => a -> [a] -> a Source #

minimumDef :: Ord a => a -> [a] -> a Source #

maximumMay :: Ord a => [a] -> Maybe a Source #

minimumMay :: Ord a => [a] -> Maybe a Source #

lastDef :: a -> [a] -> a Source #

lastMay :: [a] -> Maybe a Source #

tailSafe :: [a] -> [a] Source #

tailDef :: [a] -> [a] -> [a] Source #

tailMay :: [a] -> Maybe [a] Source #

initSafe :: [a] -> [a] Source #

initDef :: [a] -> [a] -> [a] Source #

initMay :: [a] -> Maybe [a] Source #

headDef :: a -> [a] -> a Source #

headMay :: [a] -> Maybe a Source #

panic :: HasCallStack => Text -> a Source #

newtype FatalError Source #

Uncatchable exceptions thrown and never caught.

Constructors

FatalError
Fields fatalErrorMessage :: Text

Instances

Instances details

Show FatalError
Instance details Defined in Protolude.Panic Methods showsPrec :: Int -> FatalError -> ShowS Source # show :: FatalError -> String Source # showList :: [ FatalError ] -> ShowS Source #
Exception FatalError
Instance details Defined in Protolude.Panic Methods toException :: FatalError -> SomeException Source # fromException :: SomeException -> Maybe FatalError Source # displayException :: FatalError -> String Source #

liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c Source #

liftM' :: Monad m => (a -> b) -> m a -> m b Source #

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b] Source #

sum :: ( Foldable f, Num a) => f a -> a Source #

product :: ( Foldable f, Num a) => f a -> a Source #

list :: [b] -> (a -> b) -> [a] -> [b] Source #

ordNub :: Ord a => [a] -> [a] Source #

sortOn :: Ord o => (a -> o) -> [a] -> [a] Source #

head :: Foldable f => f a -> Maybe a Source #

foreach :: Functor f => f a -> (a -> b) -> f b Source #

(<<$>>) :: ( Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b) infixl 4 Source #

tryIO :: forall (m :: Type -> Type ) a. MonadIO m => IO a -> ExceptT IOException m a Source #

note :: MonadError e m => e -> Maybe a -> m a Source #

hush :: Alternative m => Either e a -> m a Source #

maybeToEither :: e -> Maybe a -> Either e a Source #

maybeEmpty :: Monoid b => (a -> b) -> Maybe a -> b Source #

maybeToLeft :: r -> Maybe l -> Either l r Source #

maybeToRight :: l -> Maybe r -> Either l r Source #

rightToMaybe :: Either l r -> Maybe r Source #

leftToMaybe :: Either l r -> Maybe l Source #

toUtf8Lazy :: ConvertText a Text => a -> ByteString Source #

toUtf8 :: ConvertText a Text => a -> ByteString Source #

class ConvertText a b where Source #

Convert from one Unicode textual type to another. Not for serialization/deserialization, so doesn't have instances for bytestrings.

Methods

toS :: a -> b Source #

Instances

Instances details

ConvertText String String
Instance details Defined in Protolude.ConvertText Methods toS :: String -> String Source #
ConvertText String Text
Instance details Defined in Protolude.ConvertText Methods toS :: String -> Text Source #
ConvertText String Text
Instance details Defined in Protolude.ConvertText Methods toS :: String -> Text Source #
ConvertText Text String
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> String Source #
ConvertText Text Text
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> Text Source #
ConvertText Text Text
Instance details Defined in Protolude.ConvertText Methods toS :: Text0 -> Text Source #
ConvertText Text String
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> String Source #
ConvertText Text Text
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> Text0 Source #
ConvertText Text Text
Instance details Defined in Protolude.ConvertText Methods toS :: Text -> Text Source #

(<&&>) :: Applicative a => a Bool -> a Bool -> a Bool infixr 3 Source #

&& lifted to an Applicative. Unlike &&^ the operator is not short-circuiting.

(&&^) :: Monad m => m Bool -> m Bool -> m Bool infixr 3 Source #

The && operator lifted to a monad. If the first argument evaluates to False the second argument will not be evaluated.

(<||>) :: Applicative a => a Bool -> a Bool -> a Bool infixr 2 Source #

|| lifted to an Applicative. Unlike ||^ the operator is not short-circuiting.

(||^) :: Monad m => m Bool -> m Bool -> m Bool infixr 2 Source #

The || operator lifted to a monad. If the first argument evaluates to True the second argument will not be evaluated.

guardM :: MonadPlus m => m Bool -> m () Source #

ifM :: Monad m => m Bool -> m a -> m a -> m a Source #

unlessM :: Monad m => m Bool -> m () -> m () Source #

whenM :: Monad m => m Bool -> m () -> m () Source #

bool :: a -> a -> Bool -> a Source #

($!) :: (a -> b) -> a -> b infixr 0 Source #

(<<*>>) :: ( Applicative f, Applicative g) => f (g (a -> b)) -> f (g a) -> f (g b) infixl 4 Source #

liftAA2 :: ( Applicative f, Applicative g) => (a -> b -> c) -> f (g a) -> f (g b) -> f (g c) Source #

purer :: ( Applicative f, Applicative g) => a -> f (g a) Source #

eitherA :: Alternative f => f a -> f b -> f ( Either a b) Source #

orEmpty :: Alternative f => Bool -> a -> f a Source #

orAlt :: ( Alternative f, Monoid a) => f a -> f a Source #

throwE :: forall (m :: Type -> Type ) e a. Monad m => e -> ExceptT e m a Source #

Signal an exception value e .

```
runExceptT (throwE e) = return (Left e)
```
```
throwE e >>= m = throwE e
```

catchE Source #

Arguments

:: forall (m :: Type -> Type ) e a e'. Monad m
=> ExceptT e m a	the inner computation
-> (e -> ExceptT e' m a)	a handler for exceptions in the inner computation
-> ExceptT e' m a

Handle an exception.

```
catchE (lift m) h = lift m
```
```
catchE (throwE e) h = h e
```

data UnicodeException Source #

An exception type for representing Unicode encoding errors.

Instances

Instances details

Eq UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool Source # (/=) :: UnicodeException -> UnicodeException -> Bool Source #
Show UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods showsPrec :: Int -> UnicodeException -> ShowS Source # show :: UnicodeException -> String Source # showList :: [ UnicodeException ] -> ShowS Source #
Exception UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods toException :: UnicodeException -> SomeException Source # fromException :: SomeException -> Maybe UnicodeException Source # displayException :: UnicodeException -> String Source #
NFData UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods rnf :: UnicodeException -> () Source #

type OnDecodeError = OnError Word8 Char Source #

A handler for a decoding error.

type OnError a b = String -> Maybe a -> Maybe b Source #

Function type for handling a coding error. It is supplied with two inputs:

A String that describes the error.
The input value that caused the error. If the error arose because the end of input was reached or could not be identified precisely, this value will be Nothing .

If the handler returns a value wrapped with Just , that value will be used in the output as the replacement for the invalid input. If it returns Nothing , no value will be used in the output.

Should the handler need to abort processing, it should use error or throw an exception (preferably a UnicodeException ). It may use the description provided to construct a more helpful error report.

strictDecode :: OnDecodeError Source #

Throw a UnicodeException if decoding fails.

lenientDecode :: OnDecodeError Source #

Replace an invalid input byte with the Unicode replacement character U+FFFD.

ignore :: OnError a b Source #

Ignore an invalid input, substituting nothing in the output.

replace :: b -> OnError a b Source #

Replace an invalid input with a valid output.

decodeUtf8With :: OnDecodeError -> ByteString -> Text Source #

Decode a ByteString containing UTF-8 encoded text.

NOTE : The replacement character returned by OnDecodeError MUST be within the BMP plane; surrogate code points will automatically be remapped to the replacement char U+FFFD ( since 0.11.3.0 ), whereas code points beyond the BMP will throw an error ( since 1.2.3.1 ); For earlier versions of text using those unsupported code points would result in undefined behavior.

decodeUtf8 :: ByteString -> Text Source #

Decode a ByteString containing UTF-8 encoded text that is known to be valid.

If the input contains any invalid UTF-8 data, an exception will be thrown that cannot be caught in pure code. For more control over the handling of invalid data, use decodeUtf8' or decodeUtf8With .

decodeUtf8' :: ByteString -> Either UnicodeException Text Source #

Decode a ByteString containing UTF-8 encoded text.

If the input contains any invalid UTF-8 data, the relevant exception will be returned, otherwise the decoded text.

encodeUtf8 :: Text -> ByteString Source #

Encode text using UTF-8 encoding.

words :: Text -> [ Text ] Source #

O(n) Breaks a Text up into a list of words, delimited by Char s representing white space.

lines :: Text -> [ Text ] Source #

O(n) Breaks a Text up into a list of Text s at newline Char s. The resulting strings do not contain newlines.

unlines :: [ Text ] -> Text Source #

O(n) Joins lines, after appending a terminating newline to each.

unwords :: [ Text ] -> Text Source #

O(n) Joins words using single space characters.

toStrict :: Text -> Text Source #

O(n) Convert a lazy Text into a strict Text .

fromStrict :: Text -> Text Source #

O(c) Convert a strict Text into a lazy Text .

readFile :: FilePath -> IO Text Source #

The readFile function reads a file and returns the contents of the file as a string. The entire file is read strictly, as with getContents .

writeFile :: FilePath -> Text -> IO () Source #

Write a string to a file. The file is truncated to zero length before writing begins.

appendFile :: FilePath -> Text -> IO () Source #

Write a string the end of a file.

interact :: ( Text -> Text ) -> IO () Source #

The interact function takes a function of type Text -> Text as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.

getContents :: IO Text Source #

Read all user input on stdin as a single string.

getLine :: IO Text Source #

Read a single line of user input from stdin .

check :: Bool -> STM () Source #

Check that the boolean condition is true and, if not, retry .

In other words, check b = unless b retry .

Since: stm-2.1.1

identity :: Category cat => cat a a Source #

Rename id to identity to allow id as a variable name

putTextLn :: Text -> IO () Source #

Explicit output with Text since that is what we want most of the time. We don't want to look at the type errors or warnings arising.

length :: HasLength a => a -> Int Source #

We can pass several things here, as long as they have length.