Safe Haskell	None
Language	Haskell2010

Preamble

Description

Public Module

Synopsis

class Monad m => MonadReader r (m :: * -> *) | m -> r
class MonadIO m => MonadResource (m :: * -> *)
runResourceT :: MonadUnliftIO m => ResourceT m a -> m a
class MonadBase b m => MonadBaseControl (b :: * -> *) (m :: * -> *) | m -> b
type MonadControl m = (MonadBaseControl IO m, MonadIO m, MonadMask m, MonadRandom m)
type Stat = ByteString -> IO ()
type Logger = Loc -> LogSource -> LogLevel -> LogStr -> IO ()
type Tags = [(Text, Text)]
type Pairs = [(Text, Value)]
data Ctx = Ctx {
- _cPreamble :: Pairs
- _cLogger :: Logger
}
data StatsCtx = StatsCtx {
- _scCtx :: Ctx
- _scLabels :: Tags
- _scStat :: Stat
- _scPrefix :: Text
}
type MonadCtx c m = (MonadControl m, MonadReader c m, MonadLogger m, MonadCatch m, MonadThrow m, HasCtx c)
class HasCtx c where
type MonadStatsCtx c m = (MonadCtx c m, HasStatsCtx c)
class HasCtx c => HasStatsCtx c where
newtype TransT c m a = TransT {
- unTransT :: LoggingT (ReaderT c m) a
}
newStderrLogger :: MonadIO m => LogLevel -> m Logger
newStdoutLogger :: MonadIO m => LogLevel -> m Logger
nullLogger :: Logger
traceDebug :: MonadCtx c m => Text -> Pairs -> m ()
traceInfo :: MonadCtx c m => Text -> Pairs -> m ()
traceWarn :: MonadCtx c m => Text -> Pairs -> m ()
traceError :: MonadCtx c m => Text -> Pairs -> m ()
(.=) :: (KeyValue kv, ToJSON v) => Text -> v -> kv
statsCount :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
statsGauge :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
statsHistogram :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
statsTimer :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
statsSet :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
statsIncrement :: MonadStatsCtx c m => Text -> Tags -> m ()
statsDecrement :: MonadStatsCtx c m => Text -> Tags -> m ()
seq :: a -> b -> b
filter :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
fst :: (a, b) -> a
snd :: (a, b) -> b
otherwise :: Bool
assert :: Bool -> a -> a
($) :: (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
class Enum a where
class Eq a where
class Fractional a => Floating a where
class Num a => Fractional a where
class (Real a, Enum a) => Integral a where
class Applicative m => Monad (m :: * -> *) where
class Functor (f :: * -> *) where
class Num a where
class Eq a => Ord a where
class Read a where
class (Num a, Ord a) => Real a where
class (RealFrac a, Floating a) => RealFloat a where
class (Real a, Fractional a) => RealFrac a where
class Show a where
class Typeable (a :: k)
class IsString a where
class Functor f => Applicative (f :: * -> *) where
class Foldable (t :: * -> *) where
class (Functor t, Foldable t) => Traversable (t :: * -> *) where
(<>) :: Semigroup a => a -> a -> a
class Semigroup a => Monoid a where
data Bool
- = False
- | True
data Char
data Double
data Float
data Int
data Int32
data Int64
data Integer
data Maybe a
- = Nothing
- | Just a
data Ordering
- = LT
- | EQ
- | GT
type Rational = Ratio Integer
data IO a
data Word
data Word8
data Word32
data Word64
data Either a b
- = Left a
- | Right b
lift :: (MonadTrans t, Monad m) => m a -> t m a
class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where
(=<<) :: Monad m => (a -> m b) -> m a -> m b
when :: Applicative f => Bool -> f () -> f ()
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
ap :: Monad m => m (a -> b) -> m a -> m b
void :: Functor f => f a -> f ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
forever :: Applicative f => f a -> f b
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
replicateM :: Applicative m => Int -> m a -> m [a]
replicateM_ :: Applicative m => Int -> m a -> m ()
unless :: Applicative f => Bool -> f () -> f ()
(<$!>) :: Monad m => (a -> b) -> m a -> m b
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
class Monad m => MonadIO (m :: * -> *) where
either :: (a -> c) -> (b -> c) -> Either a b -> c
class Contravariant (f :: * -> *) where
data ByteString
(<$>) :: Functor f => (a -> b) -> f a -> f b
type String = [Char]
class Hashable a where
data Text
data HashMap k v
data Map k a
(<|>) :: Alternative f => f a -> f a -> f a
class Bifunctor (p :: * -> * -> *) where
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
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)
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
first :: Arrow a => a b c -> a (b, d) (c, d)
second :: Arrow a => a b c -> a (d, b) (d, c)
(***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
newtype Identity a = Identity {
- runIdentity :: a
}
catchIOError :: IO a -> (IOError -> IO a) -> IO a
annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
modifyIOError :: (IOError -> IOError) -> IO a -> IO a
ioeSetFileName :: IOError -> FilePath -> IOError
ioeSetHandle :: IOError -> Handle -> IOError
ioeSetLocation :: IOError -> String -> IOError
ioeSetErrorString :: IOError -> String -> IOError
ioeSetErrorType :: IOError -> IOErrorType -> IOError
ioeGetFileName :: IOError -> Maybe FilePath
ioeGetHandle :: IOError -> Maybe Handle
ioeGetLocation :: IOError -> String
ioeGetErrorString :: IOError -> String
ioeGetErrorType :: IOError -> IOErrorType
isUserErrorType :: IOErrorType -> Bool
isPermissionErrorType :: IOErrorType -> Bool
isIllegalOperationErrorType :: IOErrorType -> Bool
isEOFErrorType :: IOErrorType -> Bool
isFullErrorType :: IOErrorType -> Bool
isAlreadyInUseErrorType :: IOErrorType -> Bool
isDoesNotExistErrorType :: IOErrorType -> Bool
isAlreadyExistsErrorType :: IOErrorType -> Bool
userErrorType :: IOErrorType
permissionErrorType :: IOErrorType
illegalOperationErrorType :: IOErrorType
eofErrorType :: IOErrorType
fullErrorType :: IOErrorType
alreadyInUseErrorType :: IOErrorType
doesNotExistErrorType :: IOErrorType
alreadyExistsErrorType :: IOErrorType
isUserError :: IOError -> Bool
isPermissionError :: IOError -> Bool
isIllegalOperation :: IOError -> Bool
isEOFError :: IOError -> Bool
isFullError :: IOError -> Bool
isAlreadyInUseError :: IOError -> Bool
isDoesNotExistError :: IOError -> Bool
isAlreadyExistsError :: IOError -> Bool
mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
tryIOError :: IO a -> IO (Either IOError a)
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> 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
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 where
- SomeAsyncException :: SomeAsyncException
data AsyncException
- = StackOverflow
- | HeapOverflow
- | ThreadKilled
- | UserInterrupt
data ArrayException
- = IndexOutOfBounds String
- | UndefinedElement String
data IOErrorType
interruptible :: IO a -> IO a
type FilePath = String
data MaskingState
- = Unmasked
- | MaskedInterruptible
- | MaskedUninterruptible
userError :: String -> IOError
data IOException
type IOError = IOException
throw :: Exception e => e -> a
class (Typeable e, Show e) => Exception e where
data ErrorCall where
- ErrorCallWithLocation String String
- pattern ErrorCall :: String -> ErrorCall
data ArithException
- = Overflow
- | Underflow
- | LossOfPrecision
- | DivideByZero
- | Denormal
- | RatioZeroDenominator
newtype Const a (b :: k) :: forall k. * -> 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]
asum :: (Foldable t, Alternative f) => t (f a) -> f a
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 ()
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
sortOn :: Ord b => (a -> b) -> [a] -> [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]]
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
genericReplicate :: Integral i => i -> a -> [a]
genericIndex :: Integral i => [a] -> i -> 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
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
insert :: Ord a => a -> [a] -> [a]
partition :: (a -> Bool) -> [a] -> ([a], [a])
transpose :: [[a]] -> [[a]]
intersperse :: a -> [a] -> [a]
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
intersect :: Eq a => [a] -> [a] -> [a]
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
union :: Eq a => [a] -> [a] -> [a]
(\\) :: Eq a => [a] -> [a] -> [a]
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
delete :: Eq a => a -> [a] -> [a]
nubBy :: (a -> a -> Bool) -> [a] -> [a]
nub :: Eq a => [a] -> [a]
isInfixOf :: Eq a => [a] -> [a] -> Bool
isSuffixOf :: Eq a => [a] -> [a] -> Bool
isPrefixOf :: Eq a => [a] -> [a] -> Bool
findIndices :: (a -> Bool) -> [a] -> [Int]
findIndex :: (a -> Bool) -> [a] -> Maybe Int
elemIndices :: Eq a => a -> [a] -> [Int]
elemIndex :: Eq a => a -> [a] -> Maybe Int
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
dropWhileEnd :: (a -> Bool) -> [a] -> [a]
reads :: Read a => ReadS a
partitionEithers :: [Either a b] -> ([a], [b])
rights :: [Either a b] -> [b]
lefts :: [Either a b] -> [a]
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
newtype Down a = Down a
id :: Category cat => cat a a
(.) :: Category cat => cat b c -> cat a b -> cat a c
class Storable a
lex :: ReadS String
readParen :: Bool -> ReadS a -> ReadS a
type ReadS a = String -> [(a, String)]
bool :: a -> a -> Bool -> a
(&) :: a -> (a -> b) -> b
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
(<&>) :: Functor f => f a -> (a -> b) -> f b
lcm :: Integral a => a -> a -> a
gcd :: Integral a => a -> a -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^) :: (Num a, Integral b) => a -> b -> a
odd :: Integral a => a -> Bool
even :: Integral a => a -> Bool
showParen :: Bool -> ShowS -> ShowS
showString :: String -> ShowS
showChar :: Char -> ShowS
shows :: Show a => a -> ShowS
type ShowS = String -> String
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
unzip :: [(a, b)] -> ([a], [b])
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
(!!) :: [a] -> Int -> a
lookup :: Eq a => a -> [(a, b)] -> Maybe b
reverse :: [a] -> [a]
break :: (a -> Bool) -> [a] -> ([a], [a])
span :: (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]
iterate :: (a -> a) -> a -> [a]
scanr1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanl' :: (b -> a -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
foldl1' :: (a -> a -> a) -> [a] -> a
init :: [a] -> [a]
last :: [a] -> a
tail :: [a] -> [a]
uncons :: [a] -> Maybe (a, [a])
head :: [a] -> a
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
swap :: (a, b) -> (b, a)
uncurry :: (a -> b -> c) -> (a, b) -> c
curry :: ((a, b) -> c) -> a -> b -> c
subtract :: Num a => a -> a -> a
asTypeOf :: a -> a -> a
until :: (a -> Bool) -> (a -> a) -> a -> a
($!) :: (a -> b) -> a -> b
flip :: (a -> b -> c) -> b -> a -> c
const :: a -> b -> a
undefined :: HasCallStack => a
error :: HasCallStack => [Char] -> a
data SomeException where
- SomeException :: SomeException
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
readLn :: (MonadIO m, Read a) => m a
putChar :: MonadIO m => Char -> m ()
getChar :: MonadIO m => m Char
readMay :: Read a => Text -> Maybe a
interact :: MonadIO m => (LText -> LText) -> m ()
getContents :: MonadIO m => m LText
getLine :: MonadIO m => m Text
decodeUtf8 :: ByteString -> Text
fpToString :: FilePath -> String
fpFromText :: Text -> FilePath
fpToText :: FilePath -> Text
ltextToString :: LText -> String
textToString :: Text -> String
appendFile :: MonadIO m => FilePath -> Text -> m ()
writeFile :: MonadIO m => FilePath -> Text -> m ()
readFile :: MonadIO m => FilePath -> m Text
readIO :: (MonadIO m, Read a) => Text -> m a
read :: Read a => Text -> a
fromShow :: (Show a, IsString b) => a -> b
tshow :: Show a => a -> Text
product :: (Foldable f, Num a) => f a -> a
sum :: (Foldable f, Num a) => f a -> a
intercalate :: Monoid w => w -> [w] -> w
concat :: Monoid w => [w] -> w
(++) :: Monoid w => w -> w -> w
empty :: Monoid w => w
map :: Functor f => (a -> b) -> f a -> f b
terror :: HasCallStack => Text -> a
print :: (MonadIO m, Show a) => a -> m ()
putStrLn :: MonadIO m => Text -> m ()
putStr :: MonadIO m => Text -> m ()
getArgs :: MonadIO m => m [Text]
equating :: Eq a => (b -> a) -> b -> b -> Bool
type LText = Text
type LByteString = ByteString
type UVector = Vector
type SVector = Vector
data Vector a
class (Vector Vector a, MVector MVector a) => Unbox a
data HashSet a
encodeUtf8 :: Text -> ByteString
words :: Text -> [Text]
lines :: Text -> [Text]
unlines :: [Text] -> Text
unwords :: [Text] -> Text
(<.>) :: FilePath -> String -> FilePath
(</>) :: FilePath -> FilePath -> FilePath
data Set a
data Seq a
data IntSet
data IntMap a
class Profunctor (p :: * -> * -> *) where
defaultFieldRules :: LensRules
makeFieldsNoPrefix :: Name -> DecsQ
makeFields :: Name -> DecsQ
abbreviatedNamer :: FieldNamer
abbreviatedFields :: LensRules
classUnderscoreNoPrefixNamer :: FieldNamer
classUnderscoreNoPrefixFields :: LensRules
camelCaseNamer :: FieldNamer
camelCaseFields :: LensRules
underscoreNamer :: FieldNamer
underscoreFields :: LensRules
makeWrapped :: Name -> DecsQ
declareLensesWith :: LensRules -> DecsQ -> DecsQ
declareFields :: DecsQ -> DecsQ
declareWrapped :: DecsQ -> DecsQ
declarePrisms :: DecsQ -> DecsQ
declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ
declareClassy :: DecsQ -> DecsQ
declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ
declareLenses :: DecsQ -> DecsQ
makeLensesWith :: LensRules -> Name -> DecsQ
makeClassyFor :: String -> String -> [(String, String)] -> Name -> DecsQ
makeLensesFor :: [(String, String)] -> Name -> DecsQ
makeClassy_ :: Name -> DecsQ
makeClassy :: Name -> DecsQ
makeLenses :: Name -> DecsQ
classyRules_ :: LensRules
classyRules :: LensRules
mappingNamer :: (String -> [String]) -> FieldNamer
lookingupNamer :: [(String, String)] -> FieldNamer
lensRulesFor :: [(String, String)] -> LensRules
underscoreNoPrefixNamer :: FieldNamer
lensRules :: LensRules
lensClass :: Lens' LensRules ClassyNamer
lensField :: Lens' LensRules FieldNamer
createClass :: Lens' LensRules Bool
generateLazyPatterns :: Lens' LensRules Bool
generateUpdateableOptics :: Lens' LensRules Bool
generateSignatures :: Lens' LensRules Bool
simpleLenses :: Lens' LensRules Bool
data LensRules
type FieldNamer = Name -> [Name] -> Name -> [DefName]
data DefName
- = TopName Name
- | MethodName Name Name
type ClassyNamer = Name -> Maybe (Name, Name)
makeClassyPrisms :: Name -> DecsQ
makePrisms :: Name -> DecsQ
iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m))
sans :: At m => Index m -> m -> m
ixAt :: At m => Index m -> Traversal' m (IxValue m)
iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m)
icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool
type family Index s :: *
class Contains m where
type family IxValue m :: *
class Ixed m where
class Ixed m => At m where
class Each s t a b | s -> a, t -> b, s b -> t, t a -> s where
gplate :: (Generic a, GPlated a (Rep a)) => Traversal' a a
parts :: Plated a => Lens' a [a]
composOpFold :: Plated a => b -> (b -> b -> b) -> (a -> b) -> a -> b
para :: Plated a => (a -> [r] -> r) -> a -> r
paraOf :: Getting (Endo [a]) a a -> (a -> [r] -> r) -> a -> r
holesOnOf :: Conjoined p => LensLike (Bazaar p r r) s t a b -> Over p (Bazaar p r r) a b r r -> s -> [Pretext p r r t]
holesOn :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
holes :: Plated a => a -> [Pretext ((->) :: * -> * -> *) a a a]
contextsOnOf :: ATraversal s t a a -> ATraversal' a a -> s -> [Context a a t]
contextsOn :: Plated a => ATraversal s t a a -> s -> [Context a a t]
contextsOf :: ATraversal' a a -> a -> [Context a a a]
contexts :: Plated a => a -> [Context a a a]
transformMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m b) -> s -> m t
transformMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
transformMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m a) -> s -> m t
transformM :: (Monad m, Plated a) => (a -> m a) -> a -> m a
transformOnOf :: ASetter s t a b -> ASetter a b a b -> (b -> b) -> s -> t
transformOf :: ASetter a b a b -> (b -> b) -> a -> b
transformOn :: Plated a => ASetter s t a a -> (a -> a) -> s -> t
transform :: Plated a => (a -> a) -> a -> a
cosmosOnOf :: (Applicative f, Contravariant f) => LensLike' f s a -> LensLike' f a a -> LensLike' f s a
cosmosOn :: (Applicative f, Contravariant f, Plated a) => LensLike' f s a -> LensLike' f s a
cosmosOf :: (Applicative f, Contravariant f) => LensLike' f a a -> LensLike' f a a
cosmos :: Plated a => Fold a a
universeOnOf :: Getting [a] s a -> Getting [a] a a -> s -> [a]
universeOn :: Plated a => Getting [a] s a -> s -> [a]
universeOf :: Getting [a] a a -> a -> [a]
universe :: Plated a => a -> [a]
rewriteMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> s -> m t
rewriteMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m (Maybe a)) -> s -> m t
rewriteMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
rewriteM :: (Monad m, Plated a) => (a -> m (Maybe a)) -> a -> m a
rewriteOnOf :: ASetter s t a b -> ASetter a b a b -> (b -> Maybe a) -> s -> t
rewriteOn :: Plated a => ASetter s t a a -> (a -> Maybe a) -> s -> t
rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b
rewrite :: Plated a => (a -> Maybe a) -> a -> a
children :: Plated a => a -> [a]
deep :: (Conjoined p, Applicative f, Plated s) => Traversing p f s s a b -> Over p f s s a b
(...) :: (Applicative f, Plated c) => LensLike f s t c c -> Over p f c c a b -> Over p f s t a b
class Plated a where
class GPlated a (g :: * -> *)
type family Zoomed (m :: * -> *) :: * -> * -> *
type family Magnified (m :: * -> *) :: * -> * -> *
class (MonadState s m, MonadState t n) => Zoom (m :: * -> *) (n :: * -> *) s t | m -> s, n -> t, m t -> n, n s -> m where
class (Magnified m ~ Magnified n, MonadReader b m, MonadReader a n) => Magnify (m :: * -> *) (n :: * -> *) b a | m -> b, n -> a, m a -> n, n b -> m where
alaf :: (Functor f, Functor g, Rewrapping s t) => (Unwrapped s -> s) -> (f t -> g s) -> f (Unwrapped t) -> g (Unwrapped s)
ala :: (Functor f, Rewrapping s t) => (Unwrapped s -> s) -> ((Unwrapped t -> t) -> f s) -> f (Unwrapped s)
_Unwrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso (Unwrapped t) (Unwrapped s) t s
_Wrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso s t (Unwrapped s) (Unwrapped t)
_Unwrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' (Unwrapped s) s
_Wrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' s (Unwrapped s)
op :: Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
_Unwrapped :: Rewrapping s t => Iso (Unwrapped t) (Unwrapped s) t s
_Wrapped :: Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
_Unwrapped' :: Wrapped s => Iso' (Unwrapped s) s
_GWrapped' :: (Generic s, D1 d (C1 c (S1 s' (Rec0 a))) ~ Rep s, Unwrapped s ~ GUnwrapped (Rep s)) => Iso' s (Unwrapped s)
pattern Wrapped :: forall s. Rewrapped s s => Unwrapped s -> s
pattern Unwrapped :: forall t. Rewrapped t t => t -> Unwrapped t
class Wrapped s where
- type Unwrapped s :: *
class Wrapped s => Rewrapped s t
class (Rewrapped s t, Rewrapped t s) => Rewrapping s t
unsnoc :: Snoc s s a a => s -> Maybe (s, a)
snoc :: Snoc s s a a => s -> a -> s
(|>) :: Snoc s s a a => s -> a -> s
_last :: Snoc s s a a => Traversal' s a
_init :: Snoc s s a a => Traversal' s s
_tail :: Cons s s a a => Traversal' s s
_head :: Cons s s a a => Traversal' s a
cons :: Cons s s a a => a -> s -> s
(<|) :: Cons s s a a => a -> s -> s
pattern (:<) :: forall b a. Cons b b a a => a -> b -> b
pattern (:>) :: forall a b. Snoc a a b b => a -> b -> a
class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s where
pattern Empty :: forall s. AsEmpty s => s
class AsEmpty a where
coerced :: (Coercible s a, Coercible t b) => Iso s t a b
seconding :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f x s) (g y t) (f x a) (g y b)
firsting :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f s x) (g t y) (f a x) (g b y)
bimapping :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (f s s') (g t t') (f a a') (g b b')
rmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p x s) (q y t) (p x a) (q y b)
lmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p a x) (q b y) (p s x) (q t y)
dimapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (p a s') (q b t') (p s a') (q t b')
contramapping :: Contravariant f => AnIso s t a b -> Iso (f a) (f b) (f s) (f t)
imagma :: Over (Indexed i) (Molten i a b) s t a b -> Iso s t' (Magma i t b a) (Magma j t' c c)
magma :: LensLike (Mafic a b) s t a b -> Iso s u (Magma Int t b a) (Magma j u c c)
involuted :: (a -> a) -> Iso' a a
reversed :: Reversing a => Iso' a a
lazy :: Strict lazy strict => Iso' strict lazy
flipped :: (Profunctor p, Functor f) => p (b -> a -> c) (f (b' -> a' -> c')) -> p (a -> b -> c) (f (a' -> b' -> c'))
uncurried :: (Profunctor p, Functor f) => p ((a, b) -> c) (f ((d, e) -> f)) -> p (a -> b -> c) (f (d -> e -> f))
curried :: (Profunctor p, Functor f) => p (a -> b -> c) (f (d -> e -> f)) -> p ((a, b) -> c) (f ((d, e) -> f))
anon :: a -> (a -> Bool) -> Iso' (Maybe a) a
non' :: APrism' a () -> Iso' (Maybe a) a
non :: Eq a => a -> Iso' (Maybe a) a
mapping :: (Functor f, Functor g) => AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
enum :: Enum a => Iso' Int a
under :: AnIso s t a b -> (t -> s) -> b -> a
auf :: Optic (Costar f) g s t a b -> (f a -> g b) -> f s -> g t
au :: Functor f => AnIso s t a b -> ((b -> t) -> f s) -> f a
cloneIso :: AnIso s t a b -> Iso s t a b
withIso :: AnIso s t a b -> ((s -> a) -> (b -> t) -> r) -> r
from :: AnIso s t a b -> Iso b a t s
iso :: (s -> a) -> (b -> t) -> Iso s t a b
pattern Strict :: forall s t. Strict s t => t -> s
pattern Lazy :: forall t s. Strict t s => t -> s
pattern Swapped :: forall (p :: * -> * -> *) c d. Swapped p => p d c -> p c d
pattern Reversed :: forall t. Reversing t => t -> t
pattern List :: forall l. IsList l => [Item l] -> l
type AnIso s t a b = Exchange a b a (Identity b) -> Exchange a b s (Identity t)
type AnIso' s a = AnIso s s a a
class Bifunctor p => Swapped (p :: * -> * -> *) where
class Strict lazy strict | lazy -> strict, strict -> lazy where
simple :: p a (f a) -> p a (f a)
simply :: (Optic' p f s a -> r) -> Optic' p f s a -> r
fromEq :: AnEquality s t a b -> Equality b a t s
mapEq :: AnEquality s t a b -> f s -> f a
substEq :: AnEquality s t a b -> ((s ~ a) -> (t ~ b) -> r) -> r
runEq :: AnEquality s t a b -> Identical s t a b
data Identical (a :: k) (b :: k1) (s :: k) (t :: k1) :: forall k k1. k -> k1 -> k -> k1 -> * where
- Identical :: Identical a b a b
type AnEquality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = Identical a (Proxy b) a (Proxy b) -> Identical a (Proxy b) s (Proxy t)
type AnEquality' (s :: k2) (a :: k2) = AnEquality s s a a
itraverseByOf :: IndexedTraversal i s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t
itraverseBy :: TraversableWithIndex i t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b)
ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r
ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r
imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b)
imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)
ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b)
itoList :: FoldableWithIndex i f => f a -> [(i, a)]
ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b
ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b
ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a)
iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b]
iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m ()
imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()
ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f ()
itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f ()
none :: Foldable f => (a -> Bool) -> f a -> Bool
inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a
indices :: (Indexable i p, Applicative f) => (i -> Bool) -> Optical' p (Indexed i) f a a
icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r
selfIndex :: Indexable a p => p a fb -> a -> fb
(.>) :: (st -> r) -> (kab -> st) -> kab -> r
(<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r
class Functor f => FunctorWithIndex i (f :: * -> *) | f -> i where
class Foldable f => FoldableWithIndex i (f :: * -> *) | f -> i where
class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: * -> *) | t -> i where
newtype ReifiedLens s t a b = Lens {
- runLens :: Lens s t a b
}
type ReifiedLens' s a = ReifiedLens s s a a
newtype ReifiedIndexedLens i s t a b = IndexedLens {
- runIndexedLens :: IndexedLens i s t a b
}
type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a
newtype ReifiedIndexedTraversal i s t a b = IndexedTraversal {
- runIndexedTraversal :: IndexedTraversal i s t a b
}
type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a
newtype ReifiedTraversal s t a b = Traversal {
- runTraversal :: Traversal s t a b
}
type ReifiedTraversal' s a = ReifiedTraversal s s a a
newtype ReifiedGetter s a = Getter {
- runGetter :: Getter s a
}
newtype ReifiedIndexedGetter i s a = IndexedGetter {
- runIndexedGetter :: IndexedGetter i s a
}
newtype ReifiedFold s a = Fold {
- runFold :: Fold s a
}
newtype ReifiedIndexedFold i s a = IndexedFold {
- runIndexedFold :: IndexedFold i s a
}
newtype ReifiedSetter s t a b = Setter {
- runSetter :: Setter s t a b
}
type ReifiedSetter' s a = ReifiedSetter s s a a
newtype ReifiedIndexedSetter i s t a b = IndexedSetter {
- runIndexedSetter :: IndexedSetter i s t a b
}
type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a
newtype ReifiedIso s t a b = Iso {
- runIso :: Iso s t a b
}
type ReifiedIso' s a = ReifiedIso s s a a
newtype ReifiedPrism s t a b = Prism {
- runPrism :: Prism s t a b
}
type ReifiedPrism' s a = ReifiedPrism s s a a
ilevels :: Applicative f => Traversing (Indexed i) f s t a b -> IndexedLensLike Int f s t (Level i a) (Level j b)
levels :: Applicative f => Traversing ((->) :: * -> * -> *) f s t a b -> IndexedLensLike Int f s t (Level () a) (Level () b)
sequenceByOf :: Traversal s t (f b) b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> s -> f t
traverseByOf :: Traversal s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t
confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b
deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b
failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b
ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t
failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t
elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a
elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a
element :: Traversable t => Int -> IndexedTraversal' Int (t a) a
elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a
ignored :: Applicative f => pafb -> s -> f s
traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b
traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b
traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b
imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
iforMOf :: (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t
imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t
iforOf :: (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t
itraverseOf :: (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
cloneIndexedTraversal1 :: AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b
cloneIndexPreservingTraversal1 :: ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
cloneTraversal1 :: ATraversal1 s t a b -> Traversal1 s t a b
cloneIndexedTraversal :: AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b
cloneIndexPreservingTraversal :: ATraversal s t a b -> IndexPreservingTraversal s t a b
cloneTraversal :: ATraversal s t a b -> Traversal s t a b
dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a
taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a
beside :: (Representable q, Applicative (Rep q), Applicative f, Bitraversable r) => Optical p q f s t a b -> Optical p q f s' t' a b -> Optical p q f (r s s') (r t t') a b
both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b
both :: Bitraversable r => Traversal (r a a) (r b b) a b
holesOf :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
unsafeSingular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b
singular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a
iunsafePartsOf' :: Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b]
unsafePartsOf' :: ATraversal s t a b -> Lens s t [a] [b]
iunsafePartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b]
unsafePartsOf :: Functor f => Traversing ((->) :: * -> * -> *) f s t a b -> LensLike f s t [a] [b]
ipartsOf' :: (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a]
partsOf' :: ATraversal s t a a -> Lens s t [a] [a]
ipartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a]
partsOf :: Functor f => Traversing ((->) :: * -> * -> *) f s t a a -> LensLike f s t [a] [a]
iloci :: (Indexable i p, Applicative f) => p a (f b) -> Bazaar (Indexed i) a c s -> f (Bazaar (Indexed i) b c s)
loci :: Applicative f => (a -> f b) -> Bazaar ((->) :: * -> * -> *) a c s -> f (Bazaar ((->) :: * -> * -> *) b c s)
scanl1Of :: LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t
scanr1Of :: LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t
mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumROf :: LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
transposeOf :: LensLike ZipList s t [a] a -> s -> [t]
sequenceOf :: LensLike (WrappedMonad m) s t (m b) b -> s -> m t
forMOf :: LensLike (WrappedMonad m) s t a b -> s -> (a -> m b) -> m t
mapMOf :: LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
sequenceAOf :: LensLike f s t (f b) b -> s -> f t
forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t
traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t
type ATraversal s t a b = LensLike (Bazaar ((->) :: * -> * -> *) a b) s t a b
type ATraversal' s a = ATraversal s s a a
type ATraversal1 s t a b = LensLike (Bazaar1 ((->) :: * -> * -> *) a b) s t a b
type ATraversal1' s a = ATraversal1 s s a a
type AnIndexedTraversal i s t a b = Over (Indexed i) (Bazaar (Indexed i) a b) s t a b
type AnIndexedTraversal1 i s t a b = Over (Indexed i) (Bazaar1 (Indexed i) a b) s t a b
type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a
type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a
type Traversing (p :: * -> * -> *) (f :: * -> *) s t a b = Over p (BazaarT p f a b) s t a b
type Traversing1 (p :: * -> * -> *) (f :: * -> *) s t a b = Over p (BazaarT1 p f a b) s t a b
type Traversing' (p :: * -> * -> *) (f :: * -> *) s a = Traversing p f s s a a
type Traversing1' (p :: * -> * -> *) (f :: * -> *) s a = Traversing1 p f s s a a
class Ord k => TraverseMin k (m :: * -> *) | m -> k where
class Ord k => TraverseMax k (m :: * -> *) | m -> k where
foldMapByOf :: Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldByOf :: Fold s a -> (a -> a -> a) -> a -> s -> a
idroppingWhile :: (Indexable i p, Profunctor q, Applicative f) => (i -> a -> Bool) -> Optical (Indexed i) q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f) => (i -> a -> Bool) -> Optical' (Indexed i) q (Const (Endo (f s)) :: * -> *) s a -> Optical' p q f s a
ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a
findIndicesOf :: IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
findIndexOf :: IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
(^@?!) :: HasCallStack => s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
(^@?) :: s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
(^@..) :: s -> IndexedGetting i (Endo [(i, a)]) s a -> [(i, a)]
itoListOf :: IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r
ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r
ifoldlOf' :: IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ifoldrOf' :: IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r
ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a)
ifindOf :: IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a
iconcatMapOf :: IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m ()
imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()
iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f ()
itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f ()
inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
iallOf :: IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
ianyOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
ifoldlOf :: IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ifoldrOf :: IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m
backwards :: (Profunctor p, Profunctor q) => Optical p q (Backwards f) s t a b -> Optical p q f s t a b
ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
preuses :: MonadState s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
previews :: MonadReader s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
ipre :: IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
pre :: Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
hasn't :: Getting All s a -> s -> Bool
has :: Getting Any s a -> s -> Bool
foldlMOf :: Monad m => Getting (Endo (r -> m r)) s a -> (r -> a -> m r) -> r -> s -> m r
foldrMOf :: Monad m => Getting (Dual (Endo (r -> m r))) s a -> (a -> r -> m r) -> r -> s -> m r
foldl1Of' :: HasCallStack => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldr1Of' :: HasCallStack => Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a
foldlOf' :: Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
foldrOf' :: Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
foldl1Of :: HasCallStack => Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldr1Of :: HasCallStack => Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
lookupOf :: Eq k => Getting (Endo (Maybe v)) s (k, v) -> k -> s -> Maybe v
findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a)
findOf :: Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
minimumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
maximumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
minimum1Of :: Ord a => Getting (Min a) s a -> s -> a
minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
maximum1Of :: Ord a => Getting (Max a) s a -> s -> a
maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
notNullOf :: Getting Any s a -> s -> Bool
nullOf :: Getting All s a -> s -> Bool
last1Of :: Getting (Last a) s a -> s -> a
lastOf :: Getting (Rightmost a) s a -> s -> Maybe a
first1Of :: Getting (First a) s a -> s -> a
firstOf :: Getting (Leftmost a) s a -> s -> Maybe a
(^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a
(^?) :: s -> Getting (First a) s a -> Maybe a
lengthOf :: Getting (Endo (Endo Int)) s a -> s -> Int
concatOf :: Getting [r] s [r] -> s -> [r]
concatMapOf :: Getting [r] s a -> (a -> [r]) -> s -> [r]
notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a
asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a
sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m ()
forMOf_ :: Monad m => Getting (Sequenced r m) s a -> s -> (a -> m r) -> m ()
mapMOf_ :: Monad m => Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
sequence1Of_ :: Functor f => Getting (TraversedF a f) s (f a) -> s -> f ()
for1Of_ :: Functor f => Getting (TraversedF r f) s a -> s -> (a -> f r) -> f ()
traverse1Of_ :: Functor f => Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
sequenceAOf_ :: Functor f => Getting (Traversed a f) s (f a) -> s -> f ()
forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()
traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
noneOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
allOf :: Getting All s a -> (a -> Bool) -> s -> Bool
anyOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
orOf :: Getting Any s Bool -> s -> Bool
andOf :: Getting All s Bool -> s -> Bool
(^..) :: s -> Getting (Endo [a]) s a -> [a]
toNonEmptyOf :: Getting (NonEmptyDList a) s a -> s -> NonEmpty a
toListOf :: Getting (Endo [a]) s a -> s -> [a]
foldlOf :: Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
foldrOf :: Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
foldOf :: Getting a s a -> s -> a
foldMapOf :: Getting r s a -> (a -> r) -> s -> r
lined :: Applicative f => IndexedLensLike' Int f String String
worded :: Applicative f => IndexedLensLike' Int f String String
droppingWhile :: (Conjoined p, Profunctor q, Applicative f) => (a -> Bool) -> Optical p q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a
iterated :: Apply f => (a -> a) -> LensLike' f a a
unfolded :: (b -> Maybe (a, b)) -> Fold b a
cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
replicated :: Int -> Fold a a
repeated :: Apply f => LensLike' f a a
folded64 :: Foldable f => IndexedFold Int64 (f a) a
folded :: Foldable f => IndexedFold Int (f a) a
ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b
folding :: Foldable f => (s -> f a) -> Fold s a
_Show :: (Read a, Show a) => Prism' String a
nearly :: a -> (a -> Bool) -> Prism' a ()
only :: Eq a => a -> Prism' a ()
_Void :: (Choice p, Applicative f) => p a (f Void) -> p s (f s)
_Nothing :: (Choice p, Applicative f) => p () (f ()) -> p (Maybe a) (f (Maybe a))
_Just :: (Choice p, Applicative f) => p a (f b) -> p (Maybe a) (f (Maybe b))
_Right :: (Choice p, Applicative f) => p a (f b) -> p (Either c a) (f (Either c b))
_Left :: (Choice p, Applicative f) => p a (f b) -> p (Either a c) (f (Either b c))
matching :: APrism s t a b -> s -> Either t a
isn't :: APrism s t a b -> s -> Bool
below :: Traversable f => APrism' s a -> Prism' (f s) (f a)
aside :: APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b)
without :: APrism s t a b -> APrism u v c d -> Prism (Either s u) (Either t v) (Either a c) (Either b d)
outside :: Representable p => APrism s t a b -> Lens (p t r) (p s r) (p b r) (p a r)
prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b
clonePrism :: APrism s t a b -> Prism s t a b
withPrism :: APrism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
type APrism s t a b = Market a b a (Identity b) -> Market a b s (Identity t)
type APrism' s a = APrism s s a a
reuses :: MonadState b m => AReview t b -> (t -> r) -> m r
reuse :: MonadState b m => AReview t b -> m t
reviews :: MonadReader b m => AReview t b -> (t -> r) -> m r
(#) :: AReview t b -> b -> t
review :: MonadReader b m => AReview t b -> m t
re :: AReview t b -> Getter b t
un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s
unto :: (Profunctor p, Bifunctor p, Functor f) => (b -> t) -> Optic p f s t a b
getting :: (Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a
(^@.) :: s -> IndexedGetting i (i, a) s a -> (i, a)
iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a)
iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a)
ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v)
listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v)
ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u))
listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u)
uses :: MonadState s m => LensLike' (Const r :: * -> *) s a -> (a -> r) -> m r
use :: MonadState s m => Getting a s a -> m a
(^.) :: s -> Getting a s a -> a
views :: MonadReader s m => LensLike' (Const r :: * -> *) s a -> (a -> r) -> m r
view :: MonadReader s m => Getting a s a -> m a
ilike :: (Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a
like :: (Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a
ito :: (Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a
to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a
type Getting r s a = (a -> Const r a) -> s -> Const r s
type IndexedGetting i m s a = Indexed i a (Const m a) -> s -> Const m s
type Accessing (p :: * -> * -> *) m s a = p a (Const m a) -> s -> Const m s
_19' :: Field19 s t a b => Lens s t a b
_18' :: Field18 s t a b => Lens s t a b
_17' :: Field17 s t a b => Lens s t a b
_16' :: Field16 s t a b => Lens s t a b
_15' :: Field15 s t a b => Lens s t a b
_14' :: Field14 s t a b => Lens s t a b
_13' :: Field13 s t a b => Lens s t a b
_12' :: Field12 s t a b => Lens s t a b
_11' :: Field11 s t a b => Lens s t a b
_10' :: Field10 s t a b => Lens s t a b
_9' :: Field9 s t a b => Lens s t a b
_8' :: Field8 s t a b => Lens s t a b
_7' :: Field7 s t a b => Lens s t a b
_6' :: Field6 s t a b => Lens s t a b
_5' :: Field5 s t a b => Lens s t a b
_4' :: Field4 s t a b => Lens s t a b
_3' :: Field3 s t a b => Lens s t a b
_2' :: Field2 s t a b => Lens s t a b
_1' :: Field1 s t a b => Lens s t a b
class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s where
class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s where
fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b
united :: Functor f => (() -> f ()) -> a -> f a
devoid :: Over p f Void Void a b
(<#=) :: MonadState s m => ALens s s a b -> b -> m b
(<#~) :: ALens s t a b -> b -> s -> (b, t)
(#%%=) :: MonadState s m => ALens s s a b -> (a -> (r, b)) -> m r
(<#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m b
(<#%~) :: ALens s t a b -> (a -> b) -> s -> (b, t)
(#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m ()
(#=) :: MonadState s m => ALens s s a b -> b -> m ()
(#%%~) :: Functor f => ALens s t a b -> (a -> f b) -> s -> f t
(#%~) :: ALens s t a b -> (a -> b) -> s -> t
(#~) :: ALens s t a b -> b -> s -> t
storing :: ALens s t a b -> b -> s -> t
(^#) :: s -> ALens s t a b -> a
(<<%@=) :: MonadState s m => Over (Indexed i) ((,) a) s s a b -> (i -> a -> b) -> m a
(<%@=) :: MonadState s m => Over (Indexed i) ((,) b) s s a b -> (i -> a -> b) -> m b
(%%@=) :: MonadState s m => Over (Indexed i) ((,) r) s s a b -> (i -> a -> (r, b)) -> m r
(%%@~) :: Over (Indexed i) f s t a b -> (i -> a -> f b) -> s -> f t
(<<%@~) :: Over (Indexed i) ((,) a) s t a b -> (i -> a -> b) -> s -> (a, t)
(<%@~) :: Over (Indexed i) ((,) b) s t a b -> (i -> a -> b) -> s -> (b, t)
overA :: Arrow ar => LensLike (Context a b) s t a b -> ar a b -> ar s t
(<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
(<<>~) :: Monoid m => LensLike ((,) m) s t m m -> m -> s -> (m, t)
(<<~) :: MonadState s m => ALens s s a b -> m b -> m b
(<<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
(<<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
(<<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
(<<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<<?=) :: MonadState s m => LensLike ((,) a) s s a (Maybe b) -> b -> m a
(<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a
(<<%=) :: (Strong p, MonadState s m) => Over p ((,) a) s s a b -> p a b -> m a
(<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
(<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
(<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b
(<<<>~) :: Monoid r => LensLike' ((,) r) s r -> r -> s -> (r, s)
(<<&&~) :: LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
(<<||~) :: LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
(<<**~) :: Floating a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<^^~) :: (Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
(<<^~) :: (Num a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
(<<//~) :: Fractional a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<*~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<-~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<+~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<?~) :: LensLike ((,) a) s t a (Maybe b) -> b -> s -> (a, t)
(<<.~) :: LensLike ((,) a) s t a b -> b -> s -> (a, t)
(<<%~) :: LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t)
(<&&~) :: LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
(<||~) :: LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
(<**~) :: Floating a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<^^~) :: (Fractional a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
(<^~) :: (Num a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
(<//~) :: Fractional a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<*~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<-~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<+~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<%~) :: LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t)
cloneIndexedLens :: AnIndexedLens i s t a b -> IndexedLens i s t a b
cloneIndexPreservingLens :: ALens s t a b -> IndexPreservingLens s t a b
cloneLens :: ALens s t a b -> Lens s t a b
locus :: IndexedComonadStore p => Lens (p a c s) (p b c s) a b
alongside :: LensLike (AlongsideLeft f b') s t a b -> LensLike (AlongsideRight f t) s' t' a' b' -> LensLike f (s, s') (t, t') (a, a') (b, b')
chosen :: (Conjoined p, Functor f) => p a (f b) -> p (Either a a) (f (Either b b))
choosing :: Functor f => LensLike f s t a b -> LensLike f s' t' a b -> LensLike f (Either s s') (Either t t') a b
inside :: Corepresentable p => ALens s t a b -> Lens (p e s) (p e t) (p e a) (p e b)
(??) :: Functor f => f (a -> b) -> a -> f b
(%%=) :: MonadState s m => Over p ((,) r) s s a b -> p a (r, b) -> m r
(%%~) :: LensLike f s t a b -> (a -> f b) -> s -> f t
(&~) :: s -> State s a -> s
ilens :: (s -> (i, a)) -> (s -> b -> t) -> IndexedLens i s t a b
iplens :: (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
type ALens s t a b = LensLike (Pretext ((->) :: * -> * -> *) a b) s t a b
type ALens' s a = ALens s s a a
type AnIndexedLens i s t a b = Optical (Indexed i) ((->) :: * -> * -> *) (Pretext (Indexed i) a b) s t a b
type AnIndexedLens' i s a = AnIndexedLens i s s a a
imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
mapOf :: ASetter s t a b -> (a -> b) -> s -> t
assignA :: Arrow p => ASetter s t a b -> p s b -> p s t
(.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m ()
imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
(%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
(.@~) :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
(%@~) :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
isets :: ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b
iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
iover :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a
censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a
ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a
passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a
scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m ()
(<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m ()
(<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
(<?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m b
(<.=) :: MonadState s m => ASetter s s a b -> b -> m b
(<~) :: MonadState s m => ASetter s s a b -> m b -> m ()
(||=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
(&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
(**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m ()
(^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m ()
(^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m ()
(//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m ()
(*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
(-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
(+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
(?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()
modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
(%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
assign :: MonadState s m => ASetter s s a b -> b -> m ()
(&&~) :: ASetter s t Bool Bool -> Bool -> s -> t
(||~) :: ASetter s t Bool Bool -> Bool -> s -> t
(**~) :: Floating a => ASetter s t a a -> a -> s -> t
(^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t
(^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t
(//~) :: Fractional a => ASetter s t a a -> a -> s -> t
(-~) :: Num a => ASetter s t a a -> a -> s -> t
(*~) :: Num a => ASetter s t a a -> a -> s -> t
(+~) :: Num a => ASetter s t a a -> a -> s -> t
(<?~) :: ASetter s t a (Maybe b) -> b -> s -> (b, t)
(<.~) :: ASetter s t a b -> b -> s -> (b, t)
(?~) :: ASetter s t a (Maybe b) -> b -> s -> t
(.~) :: ASetter s t a b -> b -> s -> t
(%~) :: ASetter s t a b -> (a -> b) -> s -> t
set' :: ASetter' s a -> a -> s -> s
set :: ASetter s t a b -> b -> s -> t
over :: ASetter s t a b -> (a -> b) -> s -> t
cloneIndexedSetter :: AnIndexedSetter i s t a b -> IndexedSetter i s t a b
cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b
cloneSetter :: ASetter s t a b -> Setter s t a b
sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b
setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b
argument :: Profunctor p => Setter (p b r) (p a r) a b
contramapped :: Contravariant f => Setter (f b) (f a) a b
lifted :: Monad m => Setter (m a) (m b) a b
mapped :: Functor f => Setter (f a) (f b) a b
type ASetter s t a b = (a -> Identity b) -> s -> Identity t
type ASetter' s a = ASetter s s a a
type AnIndexedSetter i s t a b = Indexed i a (Identity b) -> s -> Identity t
type AnIndexedSetter' i s a = AnIndexedSetter i s s a a
type Setting (p :: * -> * -> *) s t a b = p a (Identity b) -> s -> Identity t
type Setting' (p :: * -> * -> *) s a = Setting p s s a a
type Lens s t a b = forall (f :: * -> *). Functor f => (a -> f b) -> s -> f t
type Lens' s a = Lens s s a a
type IndexedLens i s t a b = forall (f :: * -> *) (p :: * -> * -> *). (Indexable i p, Functor f) => p a (f b) -> s -> f t
type IndexedLens' i s a = IndexedLens i s s a a
type IndexPreservingLens s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Conjoined p, Functor f) => p a (f b) -> p s (f t)
type IndexPreservingLens' s a = IndexPreservingLens s s a a
type Traversal s t a b = forall (f :: * -> *). Applicative f => (a -> f b) -> s -> f t
type Traversal' s a = Traversal s s a a
type Traversal1 s t a b = forall (f :: * -> *). Apply f => (a -> f b) -> s -> f t
type Traversal1' s a = Traversal1 s s a a
type IndexedTraversal i s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Indexable i p, Applicative f) => p a (f b) -> s -> f t
type IndexedTraversal' i s a = IndexedTraversal i s s a a
type IndexedTraversal1 i s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Indexable i p, Apply f) => p a (f b) -> s -> f t
type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a
type IndexPreservingTraversal s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Conjoined p, Applicative f) => p a (f b) -> p s (f t)
type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a
type IndexPreservingTraversal1 s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Conjoined p, Apply f) => p a (f b) -> p s (f t)
type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a
type Setter s t a b = forall (f :: * -> *). Settable f => (a -> f b) -> s -> f t
type Setter' s a = Setter s s a a
type IndexedSetter i s t a b = forall (f :: * -> *) (p :: * -> * -> *). (Indexable i p, Settable f) => p a (f b) -> s -> f t
type IndexedSetter' i s a = IndexedSetter i s s a a
type IndexPreservingSetter s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Conjoined p, Settable f) => p a (f b) -> p s (f t)
type IndexPreservingSetter' s a = IndexPreservingSetter s s a a
type Iso s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Profunctor p, Functor f) => p a (f b) -> p s (f t)
type Iso' s a = Iso s s a a
type Review t b = forall (p :: * -> * -> *) (f :: * -> *). (Choice p, Bifunctor p, Settable f) => Optic' p f t b
type AReview t b = Optic' (Tagged :: * -> * -> *) Identity t b
type Prism s t a b = forall (p :: * -> * -> *) (f :: * -> *). (Choice p, Applicative f) => p a (f b) -> p s (f t)
type Prism' s a = Prism s s a a
type Equality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = forall k3 (p :: k1 -> k3 -> Type) (f :: k2 -> k3). p a (f b) -> p s (f t)
type Equality' (s :: k2) (a :: k2) = Equality s s a a
type As (a :: k2) = Equality' a a
type Getter s a = forall (f :: * -> *). (Contravariant f, Functor f) => (a -> f a) -> s -> f s
type IndexedGetter i s a = forall (p :: * -> * -> *) (f :: * -> *). (Indexable i p, Contravariant f, Functor f) => p a (f a) -> s -> f s
type IndexPreservingGetter s a = forall (p :: * -> * -> *) (f :: * -> *). (Conjoined p, Contravariant f, Functor f) => p a (f a) -> p s (f s)
type Fold s a = forall (f :: * -> *). (Contravariant f, Applicative f) => (a -> f a) -> s -> f s
type IndexedFold i s a = forall (p :: * -> * -> *) (f :: * -> *). (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> s -> f s
type IndexPreservingFold s a = forall (p :: * -> * -> *) (f :: * -> *). (Conjoined p, Contravariant f, Applicative f) => p a (f a) -> p s (f s)
type Fold1 s a = forall (f :: * -> *). (Contravariant f, Apply f) => (a -> f a) -> s -> f s
type IndexedFold1 i s a = forall (p :: * -> * -> *) (f :: * -> *). (Indexable i p, Contravariant f, Apply f) => p a (f a) -> s -> f s
type IndexPreservingFold1 s a = forall (p :: * -> * -> *) (f :: * -> *). (Conjoined p, Contravariant f, Apply f) => p a (f a) -> p s (f s)
type Simple (f :: k -> k -> k1 -> k1 -> k2) (s :: k) (a :: k1) = f s s a a
type Optic (p :: k1 -> k -> *) (f :: k2 -> k) (s :: k1) (t :: k2) (a :: k1) (b :: k2) = p a (f b) -> p s (f t)
type Optic' (p :: k1 -> k -> *) (f :: k1 -> k) (s :: k1) (a :: k1) = Optic p f s s a a
type Optical (p :: k2 -> k -> *) (q :: k1 -> k -> *) (f :: k3 -> k) (s :: k1) (t :: k3) (a :: k2) (b :: k3) = p a (f b) -> q s (f t)
type Optical' (p :: k1 -> k -> *) (q :: k1 -> k -> *) (f :: k1 -> k) (s :: k1) (a :: k1) = Optical p q f s s a a
type LensLike (f :: k -> *) s (t :: k) a (b :: k) = (a -> f b) -> s -> f t
type LensLike' (f :: * -> *) s a = LensLike f s s a a
type IndexedLensLike i (f :: k -> *) s (t :: k) a (b :: k) = forall (p :: * -> * -> *). Indexable i p => p a (f b) -> s -> f t
type IndexedLensLike' i (f :: * -> *) s a = IndexedLensLike i f s s a a
type Over (p :: k -> * -> *) (f :: k1 -> *) s (t :: k1) (a :: k) (b :: k1) = p a (f b) -> s -> f t
type Over' (p :: * -> * -> *) (f :: * -> *) s a = Over p f s s a a
class (Applicative f, Distributive f, Traversable f) => Settable (f :: * -> *)
retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b
class (Profunctor p, Bifunctor p) => Reviewable (p :: * -> * -> *)
data Magma i t b a
data Level i a
class Reversing t where
newtype Bazaar (p :: * -> * -> *) a b t = Bazaar {
- runBazaar :: forall (f :: * -> *). Applicative f => p a (f b) -> f t
}
type Bazaar' (p :: * -> * -> *) a = Bazaar p a a
newtype Bazaar1 (p :: * -> * -> *) a b t = Bazaar1 {
- runBazaar1 :: forall (f :: * -> *). Apply f => p a (f b) -> f t
}
type Bazaar1' (p :: * -> * -> *) a = Bazaar1 p a a
data Context a b t = Context (b -> t) a
type Context' a = Context a a
asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)
withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)
indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t
indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
class (Choice p, Corepresentable p, Comonad (Corep p), Traversable (Corep p), Strong p, Representable p, Monad (Rep p), MonadFix (Rep p), Distributive (Rep p), Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined (p :: * -> * -> *) where
class Conjoined p => Indexable i (p :: * -> * -> *) where
newtype Indexed i a b = Indexed {
- runIndexed :: i -> a -> b
}
data Traversed a (f :: * -> *)
data Sequenced a (m :: * -> *)
data Leftmost a
data Rightmost a
class (Foldable1 t, Traversable t) => Traversable1 (t :: * -> *) where
foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a
foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r
traverseBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b)
sequenceBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> t (f a) -> f (t a)
class Profunctor p => Choice (p :: * -> * -> *) where
onException :: MonadBaseControl IO m => m a -> m b -> m a
finally :: MonadBaseControl IO m => m a -> m b -> m a
bracketOnError :: MonadBaseControl IO m => m a -> (a -> m b) -> (a -> m c) -> m c
bracket_ :: MonadBaseControl IO m => m a -> m b -> m c -> m c
bracket :: MonadBaseControl IO m => m a -> (a -> m b) -> (a -> m c) -> m c
allowInterrupt :: MonadBase IO m => m ()
getMaskingState :: MonadBase IO m => m MaskingState
uninterruptibleMask_ :: MonadBaseControl IO m => m a -> m a
uninterruptibleMask :: MonadBaseControl IO m => ((forall a. m a -> m a) -> m b) -> m b
mask_ :: MonadBaseControl IO m => m a -> m a
mask :: MonadBaseControl IO m => ((forall a. m a -> m a) -> m b) -> m b
evaluate :: MonadBase IO m => a -> m a
tryJust :: (MonadBaseControl IO m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)
try :: (MonadBaseControl IO m, Exception e) => m a -> m (Either e a)
handleJust :: (MonadBaseControl IO m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a
handle :: (MonadBaseControl IO m, Exception e) => (e -> m a) -> m a -> m a
catchJust :: (MonadBaseControl IO m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a
catches :: MonadBaseControl IO m => m a -> [Handler m a] -> m a
catch :: (MonadBaseControl IO m, Exception e) => m a -> (e -> m a) -> m a
throwTo :: (MonadBase IO m, Exception e) => ThreadId -> e -> m ()
throwIO :: (MonadBase IO m, Exception e) => e -> m a
data Handler (m :: * -> *) a where
- Handler :: Handler m a
headMay :: [a] -> Maybe a
initMay :: [a] -> Maybe [a]
tailMay :: [a] -> Maybe [a]
maybe' :: Maybe a -> b -> (a -> b) -> b
either' :: Either a b -> (a -> c) -> (b -> c) -> c
maybe_ :: Applicative f => Maybe a -> (a -> f ()) -> f ()
eitherThrowIO :: (MonadIO m, Exception e) => Either e a -> m a
eitherThrowIO' :: MonadIO m => Either String a -> m a
maybeThrowIO :: (MonadIO m, Exception e) => e -> Maybe a -> m a
maybeThrowIO' :: MonadIO m => String -> Maybe a -> m a
boolThrowIO :: MonadIO m => String -> Bool -> m ()
textFromString :: String -> Text
textShow :: Show a => a -> Text
stringShow :: Show a => a -> String
(-/-) :: (IsString s, Monoid s) => s -> s -> s
(-|-) :: (IsString s, Monoid s) => s -> s -> s
(-.-) :: (IsString s, Monoid s) => s -> s -> s
(-:-) :: (IsString s, Monoid s) => s -> s -> s
(=.) :: a -> b -> (a, b)
makeClassyConstraints :: Name -> [Name] -> DecsQ
runTransT :: HasCtx c => c -> TransT c m a -> m a
runCtx :: MonadIO m => TransT Ctx m a -> m a
preCtx :: MonadCtx c m => Pairs -> TransT Ctx m a -> m a
runStatsCtx :: MonadCtx c m => TransT StatsCtx m a -> m a
preStatsCtx :: MonadStatsCtx c m => Pairs -> TransT StatsCtx m a -> m a
labStatsCtx :: MonadStatsCtx c m => Tags -> TransT StatsCtx m a -> m a
camelOptions :: Options
snakeOptions :: Options
spinalOptions :: Options
maybeResult :: Result a -> Maybe a
eitherResult :: Result a -> Either String a

Documentation

class Monad m => MonadReader r (m :: * -> *) | m -> r #

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

Instances

MonadReader r m => MonadReader r (ResourceT m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods ask :: ResourceT m r # local :: (r -> r) -> ResourceT m a -> ResourceT m a # reader :: (r -> a) -> ResourceT m a #
MonadReader r m => MonadReader r (NoLoggingT m)	Since: monad-logger-0.3.24
Instance details Defined in Control.Monad.Logger Methods ask :: NoLoggingT m r # local :: (r -> r) -> NoLoggingT m a -> NoLoggingT m a # reader :: (r -> a) -> NoLoggingT m a #
MonadReader r m => MonadReader r (LoggingT m)
Instance details Defined in Control.Monad.Logger Methods ask :: LoggingT m r # local :: (r -> r) -> LoggingT m a -> LoggingT m a # reader :: (r -> a) -> LoggingT m a #
MonadReader r m => MonadReader r (MaybeT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
MonadReader r m => MonadReader r (ListT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ListT m r # local :: (r -> r) -> ListT m a -> ListT m a # reader :: (r -> a) -> ListT m a #
MonadReader s (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods ask :: ReifiedGetter s s # local :: (s -> s) -> ReifiedGetter s a -> ReifiedGetter s a # reader :: (s -> a) -> ReifiedGetter s a #
MonadReader s (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods ask :: ReifiedFold s s # local :: (s -> s) -> ReifiedFold s a -> ReifiedFold s a # reader :: (s -> a) -> ReifiedFold s a #
(Functor m, MonadReader e m) => MonadReader e (Free m)
Instance details Defined in Control.Monad.Free Methods ask :: Free m e # local :: (e -> e) -> Free m a -> Free m a # reader :: (e -> a) -> Free m a #
(Representable f, Rep f ~ a) => MonadReader a (Co f)
Instance details Defined in Data.Functor.Rep Methods ask :: Co f a # local :: (a -> a) -> Co f a0 -> Co f a0 # reader :: (a -> a0) -> Co f a0 #
MonadReader r m => MonadReader r (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods ask :: RandT g m r # local :: (r -> r) -> RandT g m a -> RandT g m a # reader :: (r -> a) -> RandT g m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
MonadReader r m => MonadReader r (StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (IdentityT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: IdentityT m r # local :: (r -> r) -> IdentityT m a -> IdentityT m a # reader :: (r -> a) -> IdentityT m a #
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 # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
(Error e, MonadReader r m) => MonadReader r (ErrorT e m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ErrorT e m r # local :: (r -> r) -> ErrorT e m a -> ErrorT e m a # reader :: (r -> a) -> ErrorT e m a #
(Functor f, MonadReader r m) => MonadReader r (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods ask :: FreeT f m r # local :: (r -> r) -> FreeT f m a -> FreeT f m a # reader :: (r -> a) -> FreeT f m a #
Monad m => MonadReader c (TransT c m) #
Instance details Defined in Preamble.Types.Trans Methods ask :: TransT c m c # local :: (c -> c) -> TransT c m a -> TransT c m a # reader :: (c -> a) -> TransT c m a #
MonadReader r m => MonadReader r (ConduitT i o m)
Instance details Defined in Data.Conduit.Internal.Conduit Methods ask :: ConduitT i o m r # local :: (r -> r) -> ConduitT i o m a -> ConduitT i o m a # reader :: (r -> a) -> ConduitT i o m a #
Monad m => MonadReader r (ReaderT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ReaderT r m r # local :: (r -> r) -> ReaderT r m a -> ReaderT r m a # reader :: (r -> a) -> ReaderT r m a #
MonadReader r ((->) r :: * -> *)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: r -> r # local :: (r -> r) -> (r -> a) -> r -> a # reader :: (r -> a) -> r -> a #
MonadReader r' m => MonadReader r' (ContT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ContT r m r' # local :: (r' -> r') -> ContT r m a -> ContT r m a # reader :: (r' -> a) -> ContT r m a #
(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 # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
(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 # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
MonadReader r m => MonadReader r (Pipe l i o u m)
Instance details Defined in Data.Conduit.Internal.Pipe Methods ask :: Pipe l i o u m r # local :: (r -> r) -> Pipe l i o u m a -> Pipe l i o u m a # reader :: (r -> a) -> Pipe l i o u m a #

class MonadIO m => MonadResource (m :: * -> *) #

A Monad which allows for safe resource allocation. In theory, any monad transformer stack which includes a ResourceT can be an instance of MonadResource.

Note: runResourceT has a requirement for a MonadUnliftIO m monad, which allows control operations to be lifted. A MonadResource does not have this requirement. This means that transformers such as ContT can be an instance of MonadResource. However, the ContT wrapper will need to be unwrapped before calling runResourceT.

Since 0.3.0

Minimal complete definition

liftResourceT

Instances

MonadResource m => MonadResource (MaybeT m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> MaybeT m a #
MonadIO m => MonadResource (ResourceT m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> ResourceT m a #
MonadResource m => MonadResource (ListT m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> ListT m a #
MonadResource m => MonadResource (NoLoggingT m)
Instance details Defined in Control.Monad.Logger Methods liftResourceT :: ResourceT IO a -> NoLoggingT m a #
MonadResource m => MonadResource (LoggingT m)
Instance details Defined in Control.Monad.Logger Methods liftResourceT :: ResourceT IO a -> LoggingT m a #
MonadResource m => MonadResource (IdentityT m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> IdentityT m a #
(Monoid w, MonadResource m) => MonadResource (WriterT w m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> WriterT w m a #
(Monoid w, MonadResource m) => MonadResource (WriterT w m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> WriterT w m a #
MonadResource m => MonadResource (StateT s m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> StateT s m a #
MonadResource m => MonadResource (StateT s m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> StateT s m a #
MonadResource m => MonadResource (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> ExceptT e m a #
MonadResource m => MonadResource (TransT c m) #
Instance details Defined in Preamble.Types.Trans Methods liftResourceT :: ResourceT IO a -> TransT c m a #
MonadResource m => MonadResource (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> ReaderT r m a #
MonadResource m => MonadResource (ConduitT i o m)
Instance details Defined in Data.Conduit.Internal.Conduit Methods liftResourceT :: ResourceT IO a -> ConduitT i o m a #
MonadResource m => MonadResource (ContT r m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> ContT r m a #
(Monoid w, MonadResource m) => MonadResource (RWST r w s m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> RWST r w s m a #
(Monoid w, MonadResource m) => MonadResource (RWST r w s m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftResourceT :: ResourceT IO a -> RWST r w s m a #
MonadResource m => MonadResource (Pipe l i o u m)
Instance details Defined in Data.Conduit.Internal.Pipe Methods liftResourceT :: ResourceT IO a -> Pipe l i o u m a #

runResourceT :: MonadUnliftIO m => ResourceT m a -> m a #

Unwrap a ResourceT transformer, and call all registered release actions.

Note that there is some reference counting involved due to resourceForkIO. If multiple threads are sharing the same collection of resources, only the last call to runResourceT will deallocate the resources.

NOTE Since version 1.2.0, this function will throw a ResourceCleanupException if any of the cleanup functions throw an exception.

Since: resourcet-0.3.0

class MonadBase b m => MonadBaseControl (b :: * -> *) (m :: * -> *) | m -> b #

Writing instances

The usual way to write a MonadBaseControl instance for a transformer stack over a base monad B is to write an instance MonadBaseControl B B for the base monad, and MonadTransControl T instances for every transformer T. Instances for MonadBaseControl are then simply implemented using ComposeSt, defaultLiftBaseWith, defaultRestoreM.

Minimal complete definition

liftBaseWith, restoreM

Instances

MonadBaseControl [] []
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM [] a :: * # Methods liftBaseWith :: (RunInBase [] [] -> [a]) -> [a] # restoreM :: StM [] a -> [a] #
MonadBaseControl Maybe Maybe
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM Maybe a :: * # Methods liftBaseWith :: (RunInBase Maybe Maybe -> Maybe a) -> Maybe a # restoreM :: StM Maybe a -> Maybe a #
MonadBaseControl IO IO
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM IO a :: * # Methods liftBaseWith :: (RunInBase IO IO -> IO a) -> IO a # restoreM :: StM IO a -> IO a #
MonadBaseControl Identity Identity
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM Identity a :: * # Methods liftBaseWith :: (RunInBase Identity Identity -> Identity a) -> Identity a # restoreM :: StM Identity a -> Identity a #
MonadBaseControl STM STM
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM STM a :: * # Methods liftBaseWith :: (RunInBase STM STM -> STM a) -> STM a # restoreM :: StM STM a -> STM a #
MonadBaseControl b m => MonadBaseControl b (WriterLoggingT m)
Instance details Defined in Control.Monad.Logger Associated Types type StM (WriterLoggingT m) a :: * # Methods liftBaseWith :: (RunInBase (WriterLoggingT m) b -> b a) -> WriterLoggingT m a # restoreM :: StM (WriterLoggingT m) a -> WriterLoggingT m a #
MonadBaseControl b m => MonadBaseControl b (NoLoggingT m)
Instance details Defined in Control.Monad.Logger Associated Types type StM (NoLoggingT m) a :: * # Methods liftBaseWith :: (RunInBase (NoLoggingT m) b -> b a) -> NoLoggingT m a # restoreM :: StM (NoLoggingT m) a -> NoLoggingT m a #
MonadBaseControl b m => MonadBaseControl b (LoggingT m)
Instance details Defined in Control.Monad.Logger Associated Types type StM (LoggingT m) a :: * # Methods liftBaseWith :: (RunInBase (LoggingT m) b -> b a) -> LoggingT m a # restoreM :: StM (LoggingT m) a -> LoggingT m a #
MonadBaseControl b m => MonadBaseControl b (MaybeT m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (MaybeT m) a :: * # Methods liftBaseWith :: (RunInBase (MaybeT m) b -> b a) -> MaybeT m a # restoreM :: StM (MaybeT m) a -> MaybeT m a #
MonadBaseControl b m => MonadBaseControl b (ListT m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (ListT m) a :: * # Methods liftBaseWith :: (RunInBase (ListT m) b -> b a) -> ListT m a # restoreM :: StM (ListT m) a -> ListT m a #
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (WriterT w m) a :: * # Methods liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a # restoreM :: StM (WriterT w m) a -> WriterT w m a #
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (WriterT w m) a :: * # Methods liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a # restoreM :: StM (WriterT w m) a -> WriterT w m a #
MonadBaseControl b m => MonadBaseControl b (StateT s m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (StateT s m) a :: * # Methods liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a # restoreM :: StM (StateT s m) a -> StateT s m a #
MonadBaseControl b m => MonadBaseControl b (StateT s m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (StateT s m) a :: * # Methods liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a # restoreM :: StM (StateT s m) a -> StateT s m a #
MonadBaseControl b m => MonadBaseControl b (IdentityT m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (IdentityT m) a :: * # Methods liftBaseWith :: (RunInBase (IdentityT m) b -> b a) -> IdentityT m a # restoreM :: StM (IdentityT m) a -> IdentityT m a #
MonadBaseControl b m => MonadBaseControl b (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (ExceptT e m) a :: * # Methods liftBaseWith :: (RunInBase (ExceptT e m) b -> b a) -> ExceptT e m a # restoreM :: StM (ExceptT e m) a -> ExceptT e m a #
(Error e, MonadBaseControl b m) => MonadBaseControl b (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (ErrorT e m) a :: * # Methods liftBaseWith :: (RunInBase (ErrorT e m) b -> b a) -> ErrorT e m a # restoreM :: StM (ErrorT e m) a -> ErrorT e m a #
MonadBaseControl b m => MonadBaseControl b (TransT c m) #
Instance details Defined in Preamble.Types.Trans Associated Types type StM (TransT c m) a :: * # Methods liftBaseWith :: (RunInBase (TransT c m) b -> b a) -> TransT c m a # restoreM :: StM (TransT c m) a -> TransT c m a #
MonadBaseControl b m => MonadBaseControl b (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (ReaderT r m) a :: * # Methods liftBaseWith :: (RunInBase (ReaderT r m) b -> b a) -> ReaderT r m a # restoreM :: StM (ReaderT r m) a -> ReaderT r m a #
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (RWST r w s m) a :: * # Methods liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a # restoreM :: StM (RWST r w s m) a -> RWST r w s m a #
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (RWST r w s m) a :: * # Methods liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a # restoreM :: StM (RWST r w s m) a -> RWST r w s m a #
MonadBaseControl (Either e) (Either e)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (Either e) a :: * # Methods liftBaseWith :: (RunInBase (Either e) (Either e) -> Either e a) -> Either e a # restoreM :: StM (Either e) a -> Either e a #
MonadBaseControl (ST s) (ST s)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (ST s) a :: * # Methods liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a # restoreM :: StM (ST s) a -> ST s a #
MonadBaseControl (ST s) (ST s)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (ST s) a :: * # Methods liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a # restoreM :: StM (ST s) a -> ST s a #
MonadBaseControl ((->) r :: * -> ) ((->) r :: -> *)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM ((->) r) a :: * # Methods liftBaseWith :: (RunInBase ((->) r) ((->) r) -> r -> a) -> r -> a # restoreM :: StM ((->) r) a -> r -> a #

type MonadControl m = (MonadBaseControl IO m, MonadIO m, MonadMask m, MonadRandom m) Source #

MonadControl

type Stat = ByteString -> IO () Source #

Stat

type Logger = Loc -> LogSource -> LogLevel -> LogStr -> IO () Source #

Logger

type Tags = [(Text, Text)] Source #

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 #

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.

class Bounded a where #

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

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

Minimal complete definition

minBound, maxBound

Methods

minBound :: a #

maxBound :: a #

Instances

Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 # maxBound :: Int8 #
Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 # maxBound :: Int16 #
Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 # maxBound :: Int32 #
Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 # maxBound :: Int64 #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Bounded VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecCount # maxBound :: VecCount #
Bounded VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecElem # maxBound :: VecElem #
Bounded ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: () # maxBound :: () #
Bounded All
Instance details Defined in Data.Semigroup.Internal Methods minBound :: All # maxBound :: All #
Bounded Any
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Any # maxBound :: Any #
Bounded Associativity
Instance details Defined in GHC.Generics Methods minBound :: Associativity # maxBound :: Associativity #
Bounded SourceUnpackedness
Instance details Defined in GHC.Generics Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded SourceStrictness
Instance details Defined in GHC.Generics Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded DecidedStrictness
Instance details Defined in GHC.Generics Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded CChar
Instance details Defined in Foreign.C.Types Methods minBound :: CChar # maxBound :: CChar #
Bounded CSChar
Instance details Defined in Foreign.C.Types Methods minBound :: CSChar # maxBound :: CSChar #
Bounded CUChar
Instance details Defined in Foreign.C.Types Methods minBound :: CUChar # maxBound :: CUChar #
Bounded CShort
Instance details Defined in Foreign.C.Types Methods minBound :: CShort # maxBound :: CShort #
Bounded CUShort
Instance details Defined in Foreign.C.Types Methods minBound :: CUShort # maxBound :: CUShort #
Bounded CInt
Instance details Defined in Foreign.C.Types Methods minBound :: CInt # maxBound :: CInt #
Bounded CUInt
Instance details Defined in Foreign.C.Types Methods minBound :: CUInt # maxBound :: CUInt #
Bounded CLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLong # maxBound :: CLong #
Bounded CULong
Instance details Defined in Foreign.C.Types Methods minBound :: CULong # maxBound :: CULong #
Bounded CLLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLLong # maxBound :: CLLong #
Bounded CULLong
Instance details Defined in Foreign.C.Types Methods minBound :: CULLong # maxBound :: CULLong #
Bounded CBool
Instance details Defined in Foreign.C.Types Methods minBound :: CBool # maxBound :: CBool #
Bounded CPtrdiff
Instance details Defined in Foreign.C.Types Methods minBound :: CPtrdiff # maxBound :: CPtrdiff #
Bounded CSize
Instance details Defined in Foreign.C.Types Methods minBound :: CSize # maxBound :: CSize #
Bounded CWchar
Instance details Defined in Foreign.C.Types Methods minBound :: CWchar # maxBound :: CWchar #
Bounded CSigAtomic
Instance details Defined in Foreign.C.Types Methods minBound :: CSigAtomic # maxBound :: CSigAtomic #
Bounded CIntPtr
Instance details Defined in Foreign.C.Types Methods minBound :: CIntPtr # maxBound :: CIntPtr #
Bounded CUIntPtr
Instance details Defined in Foreign.C.Types Methods minBound :: CUIntPtr # maxBound :: CUIntPtr #
Bounded CIntMax
Instance details Defined in Foreign.C.Types Methods minBound :: CIntMax # maxBound :: CIntMax #
Bounded CUIntMax
Instance details Defined in Foreign.C.Types Methods minBound :: CUIntMax # maxBound :: CUIntMax #
Bounded GeneralCategory
Instance details Defined in GHC.Unicode Methods minBound :: GeneralCategory # maxBound :: GeneralCategory #
Bounded a => Bounded (Min a)
Instance details Defined in Data.Semigroup Methods minBound :: Min a # maxBound :: Min a #
Bounded a => Bounded (Max a)
Instance details Defined in Data.Semigroup Methods minBound :: Max a # maxBound :: Max a #
Bounded a => Bounded (First a)
Instance details Defined in Data.Semigroup Methods minBound :: First a # maxBound :: First a #
Bounded a => Bounded (Last a)
Instance details Defined in Data.Semigroup Methods minBound :: Last a # maxBound :: Last a #
Bounded m => Bounded (WrappedMonoid m)
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Bounded a => Bounded (Identity a)
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Bounded a => Bounded (Dual a)
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Dual a # maxBound :: Dual a #
Bounded a => Bounded (Sum a)
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Sum a # maxBound :: Sum a #
Bounded a => Bounded (Product a)
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Product a # maxBound :: Product a #
(Bounded a, Bounded b) => Bounded (a, b)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b) # maxBound :: (a, b) #
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c) # maxBound :: (a, b, c) #
Bounded a => Bounded (Const a b)
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b # maxBound :: a :~: b #
Bounded b => Bounded (Tagged s b)
Instance details Defined in Data.Tagged Methods minBound :: Tagged s b # maxBound :: Tagged s b #
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
a ~~ b => Bounded (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~~: b # maxBound :: a :~~: b #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e) # maxBound :: (a, b, c, d, e) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f) # maxBound :: (a, b, c, d, e, f) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g) # maxBound :: (a, b, c, d, e, f, g) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h) # maxBound :: (a, b, c, d, e, f, g, h) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i) # maxBound :: (a, b, c, d, e, f, g, h, i) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j) # maxBound :: (a, b, c, d, e, f, g, h, i, j) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

class Enum a where #

Class Enum defines operations on sequentially ordered types.

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

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

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

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

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

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a #

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

pred :: a -> a #

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

toEnum :: Int -> a #

Convert from an Int.

fromEnum :: a -> Int #

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

enumFrom :: a -> [a] #

Used in Haskell's translation of [n..].

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

Used in Haskell's translation of [n,n'..].

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

Used in Haskell's translation of [n..m].

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

Used in Haskell's translation of [n,n'..m].

Instances

Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Enum VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # toEnum :: Int -> VecCount # fromEnum :: VecCount -> Int # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] #
Enum VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecElem -> VecElem # pred :: VecElem -> VecElem # toEnum :: Int -> VecElem # fromEnum :: VecElem -> Int # enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] #
Enum ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Associativity
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] #
Enum SourceUnpackedness
Instance details Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] #
Enum SourceStrictness
Instance details Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] #
Enum DecidedStrictness
Instance details Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] #
Enum CChar
Instance details Defined in Foreign.C.Types Methods succ :: CChar -> CChar # pred :: CChar -> CChar # toEnum :: Int -> CChar # fromEnum :: CChar -> Int # enumFrom :: CChar -> [CChar] # enumFromThen :: CChar -> CChar -> [CChar] # enumFromTo :: CChar -> CChar -> [CChar] # enumFromThenTo :: CChar -> CChar -> CChar -> [CChar] #
Enum CSChar
Instance details Defined in Foreign.C.Types Methods succ :: CSChar -> CSChar # pred :: CSChar -> CSChar # toEnum :: Int -> CSChar # fromEnum :: CSChar -> Int # enumFrom :: CSChar -> [CSChar] # enumFromThen :: CSChar -> CSChar -> [CSChar] # enumFromTo :: CSChar -> CSChar -> [CSChar] # enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar] #
Enum CUChar
Instance details Defined in Foreign.C.Types Methods succ :: CUChar -> CUChar # pred :: CUChar -> CUChar # toEnum :: Int -> CUChar # fromEnum :: CUChar -> Int # enumFrom :: CUChar -> [CUChar] # enumFromThen :: CUChar -> CUChar -> [CUChar] # enumFromTo :: CUChar -> CUChar -> [CUChar] # enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar] #
Enum CShort
Instance details Defined in Foreign.C.Types Methods succ :: CShort -> CShort # pred :: CShort -> CShort # toEnum :: Int -> CShort # fromEnum :: CShort -> Int # enumFrom :: CShort -> [CShort] # enumFromThen :: CShort -> CShort -> [CShort] # enumFromTo :: CShort -> CShort -> [CShort] # enumFromThenTo :: CShort -> CShort -> CShort -> [CShort] #
Enum CUShort
Instance details Defined in Foreign.C.Types Methods succ :: CUShort -> CUShort # pred :: CUShort -> CUShort # toEnum :: Int -> CUShort # fromEnum :: CUShort -> Int # enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] #
Enum CInt
Instance details Defined in Foreign.C.Types Methods succ :: CInt -> CInt # pred :: CInt -> CInt # toEnum :: Int -> CInt # fromEnum :: CInt -> Int # enumFrom :: CInt -> [CInt] # enumFromThen :: CInt -> CInt -> [CInt] # enumFromTo :: CInt -> CInt -> [CInt] # enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] #
Enum CUInt
Instance details Defined in Foreign.C.Types Methods succ :: CUInt -> CUInt # pred :: CUInt -> CUInt # toEnum :: Int -> CUInt # fromEnum :: CUInt -> Int # enumFrom :: CUInt -> [CUInt] # enumFromThen :: CUInt -> CUInt -> [CUInt] # enumFromTo :: CUInt -> CUInt -> [CUInt] # enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt] #
Enum CLong
Instance details Defined in Foreign.C.Types Methods succ :: CLong -> CLong # pred :: CLong -> CLong # toEnum :: Int -> CLong # fromEnum :: CLong -> Int # enumFrom :: CLong -> [CLong] # enumFromThen :: CLong -> CLong -> [CLong] # enumFromTo :: CLong -> CLong -> [CLong] # enumFromThenTo :: CLong -> CLong -> CLong -> [CLong] #
Enum CULong
Instance details Defined in Foreign.C.Types Methods succ :: CULong -> CULong # pred :: CULong -> CULong # toEnum :: Int -> CULong # fromEnum :: CULong -> Int # enumFrom :: CULong -> [CULong] # enumFromThen :: CULong -> CULong -> [CULong] # enumFromTo :: CULong -> CULong -> [CULong] # enumFromThenTo :: CULong -> CULong -> CULong -> [CULong] #
Enum CLLong
Instance details Defined in Foreign.C.Types Methods succ :: CLLong -> CLLong # pred :: CLLong -> CLLong # toEnum :: Int -> CLLong # fromEnum :: CLLong -> Int # enumFrom :: CLLong -> [CLLong] # enumFromThen :: CLLong -> CLLong -> [CLLong] # enumFromTo :: CLLong -> CLLong -> [CLLong] # enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong] #
Enum CULLong
Instance details Defined in Foreign.C.Types Methods succ :: CULLong -> CULLong # pred :: CULLong -> CULLong # toEnum :: Int -> CULLong # fromEnum :: CULLong -> Int # enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] #
Enum CBool
Instance details Defined in Foreign.C.Types Methods succ :: CBool -> CBool # pred :: CBool -> CBool # toEnum :: Int -> CBool # fromEnum :: CBool -> Int # enumFrom :: CBool -> [CBool] # enumFromThen :: CBool -> CBool -> [CBool] # enumFromTo :: CBool -> CBool -> [CBool] # enumFromThenTo :: CBool -> CBool -> CBool -> [CBool] #
Enum CFloat
Instance details Defined in Foreign.C.Types Methods succ :: CFloat -> CFloat # pred :: CFloat -> CFloat # toEnum :: Int -> CFloat # fromEnum :: CFloat -> Int # enumFrom :: CFloat -> [CFloat] # enumFromThen :: CFloat -> CFloat -> [CFloat] # enumFromTo :: CFloat -> CFloat -> [CFloat] # enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat] #
Enum CDouble
Instance details Defined in Foreign.C.Types Methods succ :: CDouble -> CDouble # pred :: CDouble -> CDouble # toEnum :: Int -> CDouble # fromEnum :: CDouble -> Int # enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] #
Enum CPtrdiff
Instance details Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # toEnum :: Int -> CPtrdiff # fromEnum :: CPtrdiff -> Int # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] #
Enum CSize
Instance details Defined in Foreign.C.Types Methods succ :: CSize -> CSize # pred :: CSize -> CSize # toEnum :: Int -> CSize # fromEnum :: CSize -> Int # enumFrom :: CSize -> [CSize] # enumFromThen :: CSize -> CSize -> [CSize] # enumFromTo :: CSize -> CSize -> [CSize] # enumFromThenTo :: CSize -> CSize -> CSize -> [CSize] #
Enum CWchar
Instance details Defined in Foreign.C.Types Methods succ :: CWchar -> CWchar # pred :: CWchar -> CWchar # toEnum :: Int -> CWchar # fromEnum :: CWchar -> Int # enumFrom :: CWchar -> [CWchar] # enumFromThen :: CWchar -> CWchar -> [CWchar] # enumFromTo :: CWchar -> CWchar -> [CWchar] # enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar] #
Enum CSigAtomic
Instance details Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # toEnum :: Int -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] #
Enum CClock
Instance details Defined in Foreign.C.Types Methods succ :: CClock -> CClock # pred :: CClock -> CClock # toEnum :: Int -> CClock # fromEnum :: CClock -> Int # enumFrom :: CClock -> [CClock] # enumFromThen :: CClock -> CClock -> [CClock] # enumFromTo :: CClock -> CClock -> [CClock] # enumFromThenTo :: CClock -> CClock -> CClock -> [CClock] #
Enum CTime
Instance details Defined in Foreign.C.Types Methods succ :: CTime -> CTime # pred :: CTime -> CTime # toEnum :: Int -> CTime # fromEnum :: CTime -> Int # enumFrom :: CTime -> [CTime] # enumFromThen :: CTime -> CTime -> [CTime] # enumFromTo :: CTime -> CTime -> [CTime] # enumFromThenTo :: CTime -> CTime -> CTime -> [CTime] #
Enum CUSeconds
Instance details Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # toEnum :: Int -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] #
Enum CSUSeconds
Instance details Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # toEnum :: Int -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] #
Enum CIntPtr
Instance details Defined in Foreign.C.Types Methods succ :: CIntPtr -> CIntPtr # pred :: CIntPtr -> CIntPtr # toEnum :: Int -> CIntPtr # fromEnum :: CIntPtr -> Int # enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] #
Enum CUIntPtr
Instance details Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # toEnum :: Int -> CUIntPtr # fromEnum :: CUIntPtr -> Int # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] #
Enum CIntMax
Instance details Defined in Foreign.C.Types Methods succ :: CIntMax -> CIntMax # pred :: CIntMax -> CIntMax # toEnum :: Int -> CIntMax # fromEnum :: CIntMax -> Int # enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] #
Enum CUIntMax
Instance details Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # toEnum :: Int -> CUIntMax # fromEnum :: CUIntMax -> Int # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] #
Enum GeneralCategory
Instance details Defined in GHC.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] #
Enum Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # toEnum :: Int -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] #
Enum PortNumber
Instance details Defined in Network.Socket.Types Methods succ :: PortNumber -> PortNumber # pred :: PortNumber -> PortNumber # toEnum :: Int -> PortNumber # fromEnum :: PortNumber -> Int # enumFrom :: PortNumber -> [PortNumber] # enumFromThen :: PortNumber -> PortNumber -> [PortNumber] # enumFromTo :: PortNumber -> PortNumber -> [PortNumber] # enumFromThenTo :: PortNumber -> PortNumber -> PortNumber -> [PortNumber] #
Enum NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods succ :: NominalDiffTime -> NominalDiffTime # pred :: NominalDiffTime -> NominalDiffTime # toEnum :: Int -> NominalDiffTime # fromEnum :: NominalDiffTime -> Int # enumFrom :: NominalDiffTime -> [NominalDiffTime] # enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] #
Enum DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods succ :: DiffTime -> DiffTime # pred :: DiffTime -> DiffTime # toEnum :: Int -> DiffTime # fromEnum :: DiffTime -> Int # enumFrom :: DiffTime -> [DiffTime] # enumFromThen :: DiffTime -> DiffTime -> [DiffTime] # enumFromTo :: DiffTime -> DiffTime -> [DiffTime] # enumFromThenTo :: DiffTime -> DiffTime -> DiffTime -> [DiffTime] #
Enum Day
Instance details Defined in Data.Time.Calendar.Days Methods succ :: Day -> Day # pred :: Day -> Day # toEnum :: Int -> Day # fromEnum :: Day -> Int # enumFrom :: Day -> [Day] # enumFromThen :: Day -> Day -> [Day] # enumFromTo :: Day -> Day -> [Day] # enumFromThenTo :: Day -> Day -> Day -> [Day] #
Integral a => Enum (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods succ :: Ratio a -> Ratio a # pred :: Ratio a -> Ratio a # toEnum :: Int -> Ratio a # fromEnum :: Ratio a -> Int # enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] #
Enum a => Enum (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Min a -> Min a # pred :: Min a -> Min a # toEnum :: Int -> Min a # fromEnum :: Min a -> Int # enumFrom :: Min a -> [Min a] # enumFromThen :: Min a -> Min a -> [Min a] # enumFromTo :: Min a -> Min a -> [Min a] # enumFromThenTo :: Min a -> Min a -> Min a -> [Min a] #
Enum a => Enum (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Max a -> Max a # pred :: Max a -> Max a # toEnum :: Int -> Max a # fromEnum :: Max a -> Int # enumFrom :: Max a -> [Max a] # enumFromThen :: Max a -> Max a -> [Max a] # enumFromTo :: Max a -> Max a -> [Max a] # enumFromThenTo :: Max a -> Max a -> Max a -> [Max a] #
Enum a => Enum (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: First a -> First a # pred :: First a -> First a # toEnum :: Int -> First a # fromEnum :: First a -> Int # enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] #
Enum a => Enum (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Last a -> Last a # pred :: Last a -> Last a # toEnum :: Int -> Last a # fromEnum :: Last a -> Int # enumFrom :: Last a -> [Last a] # enumFromThen :: Last a -> Last a -> [Last a] # enumFromTo :: Last a -> Last a -> [Last a] # enumFromThenTo :: Last a -> Last a -> Last a -> [Last a] #
Enum a => Enum (WrappedMonoid a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] #
Enum a => Enum (Identity a)
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Enum a => Enum (Const a b)
Instance details Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # toEnum :: Int -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] #
Enum (f a) => Enum (Alt f a)
Instance details Defined in Data.Semigroup.Internal Methods succ :: Alt f a -> Alt f a # pred :: Alt f a -> Alt f a # toEnum :: Int -> Alt f a # fromEnum :: Alt f a -> Int # enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # toEnum :: Int -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] #
Enum a => Enum (Tagged s a)
Instance details Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a # pred :: Tagged s a -> Tagged s a # toEnum :: Int -> Tagged s a # fromEnum :: Tagged s a -> Int # enumFrom :: Tagged s a -> [Tagged s a] # enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a] #
a ~~ b => Enum (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # toEnum :: Int -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] #

class Eq a where #

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.

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

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

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

Instances

Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Integer
Instance details Defined in GHC.Integer.Type Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool #
Eq Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Eq Match
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Eq Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Eq Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Eq Type
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Eq Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Eq Name
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Eq FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Eq InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Eq Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Overlap -> Overlap -> Bool # (/=) :: Overlap -> Overlap -> Bool #
Eq DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivStrategy -> DerivStrategy -> Bool # (/=) :: DerivStrategy -> DerivStrategy -> Bool #
Eq ()
Instance details Defined in GHC.Classes Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq TyCon
Instance details Defined in GHC.Classes Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq Module
Instance details Defined in GHC.Classes Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq TrName
Instance details Defined in GHC.Classes Methods (==) :: TrName -> TrName -> Bool # (/=) :: TrName -> TrName -> Bool #
Eq Con
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Eq ByteString
Instance details Defined in Data.ByteString.Internal Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq Builder
Instance details Defined in Data.Text.Internal.Builder Methods (==) :: Builder -> Builder -> Bool # (/=) :: Builder -> Builder -> Bool #
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 # (/=) :: Scientific -> Scientific -> Bool #
Eq UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
Eq JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: JSONPathElement -> JSONPathElement -> Bool # (/=) :: JSONPathElement -> JSONPathElement -> Bool #
Eq Value
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Eq DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: DotNetTime -> DotNetTime -> Bool # (/=) :: DotNetTime -> DotNetTime -> Bool #
Eq SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: SumEncoding -> SumEncoding -> Bool # (/=) :: SumEncoding -> SumEncoding -> Bool #
Eq Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #
Eq ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadId -> ThreadId -> Bool # (/=) :: ThreadId -> ThreadId -> Bool #
Eq Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: Pos -> Pos -> Bool # (/=) :: Pos -> Pos -> Bool #
Eq More
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: More -> More -> Bool # (/=) :: More -> More -> Bool #
Eq BigNat
Instance details Defined in GHC.Integer.Type Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq SpecConstrAnnotation
Instance details Defined in GHC.Exts Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Version	Since: base-2.1
Instance details Defined in Data.Version Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq BlockReason
Instance details Defined in GHC.Conc.Sync Methods (==) :: BlockReason -> BlockReason -> Bool # (/=) :: BlockReason -> BlockReason -> Bool #
Eq ThreadStatus
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadStatus -> ThreadStatus -> Bool # (/=) :: ThreadStatus -> ThreadStatus -> Bool #
Eq AsyncException
Instance details Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Eq ArrayException
Instance details Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Eq ExitCode
Instance details Defined in GHC.IO.Exception Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Eq IOErrorType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOErrorType -> IOErrorType -> Bool # (/=) :: IOErrorType -> IOErrorType -> Bool #
Eq BufferMode
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: BufferMode -> BufferMode -> Bool # (/=) :: BufferMode -> BufferMode -> Bool #
Eq Newline
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Newline -> Newline -> Bool # (/=) :: Newline -> Newline -> Bool #
Eq NewlineMode
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: NewlineMode -> NewlineMode -> Bool # (/=) :: NewlineMode -> NewlineMode -> Bool #
Eq MaskingState
Instance details Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Eq ErrorCall
Instance details Defined in GHC.Exception Methods (==) :: ErrorCall -> ErrorCall -> Bool # (/=) :: ErrorCall -> ErrorCall -> Bool #
Eq ArithException
Instance details Defined in GHC.Exception Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Eq All
Instance details Defined in Data.Semigroup.Internal Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq Fixity
Instance details Defined in GHC.Generics Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Associativity
Instance details Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq SourceUnpackedness
Instance details Defined in GHC.Generics Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Instance details Defined in GHC.Generics Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Instance details Defined in GHC.Generics Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq CChar
Instance details Defined in Foreign.C.Types Methods (==) :: CChar -> CChar -> Bool # (/=) :: CChar -> CChar -> Bool #
Eq CSChar
Instance details Defined in Foreign.C.Types Methods (==) :: CSChar -> CSChar -> Bool # (/=) :: CSChar -> CSChar -> Bool #
Eq CUChar
Instance details Defined in Foreign.C.Types Methods (==) :: CUChar -> CUChar -> Bool # (/=) :: CUChar -> CUChar -> Bool #
Eq CShort
Instance details Defined in Foreign.C.Types Methods (==) :: CShort -> CShort -> Bool # (/=) :: CShort -> CShort -> Bool #
Eq CUShort
Instance details Defined in Foreign.C.Types Methods (==) :: CUShort -> CUShort -> Bool # (/=) :: CUShort -> CUShort -> Bool #
Eq CInt
Instance details Defined in Foreign.C.Types Methods (==) :: CInt -> CInt -> Bool # (/=) :: CInt -> CInt -> Bool #
Eq CUInt
Instance details Defined in Foreign.C.Types Methods (==) :: CUInt -> CUInt -> Bool # (/=) :: CUInt -> CUInt -> Bool #
Eq CLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLong -> CLong -> Bool # (/=) :: CLong -> CLong -> Bool #
Eq CULong
Instance details Defined in Foreign.C.Types Methods (==) :: CULong -> CULong -> Bool # (/=) :: CULong -> CULong -> Bool #
Eq CLLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLLong -> CLLong -> Bool # (/=) :: CLLong -> CLLong -> Bool #
Eq CULLong
Instance details Defined in Foreign.C.Types Methods (==) :: CULLong -> CULLong -> Bool # (/=) :: CULLong -> CULLong -> Bool #
Eq CBool
Instance details Defined in Foreign.C.Types Methods (==) :: CBool -> CBool -> Bool # (/=) :: CBool -> CBool -> Bool #
Eq CFloat
Instance details Defined in Foreign.C.Types Methods (==) :: CFloat -> CFloat -> Bool # (/=) :: CFloat -> CFloat -> Bool #
Eq CDouble
Instance details Defined in Foreign.C.Types Methods (==) :: CDouble -> CDouble -> Bool # (/=) :: CDouble -> CDouble -> Bool #
Eq CPtrdiff
Instance details Defined in Foreign.C.Types Methods (==) :: CPtrdiff -> CPtrdiff -> Bool # (/=) :: CPtrdiff -> CPtrdiff -> Bool #
Eq CSize
Instance details Defined in Foreign.C.Types Methods (==) :: CSize -> CSize -> Bool # (/=) :: CSize -> CSize -> Bool #
Eq CWchar
Instance details Defined in Foreign.C.Types Methods (==) :: CWchar -> CWchar -> Bool # (/=) :: CWchar -> CWchar -> Bool #
Eq CSigAtomic
Instance details Defined in Foreign.C.Types Methods (==) :: CSigAtomic -> CSigAtomic -> Bool # (/=) :: CSigAtomic -> CSigAtomic -> Bool #
Eq CClock
Instance details Defined in Foreign.C.Types Methods (==) :: CClock -> CClock -> Bool # (/=) :: CClock -> CClock -> Bool #
Eq CTime
Instance details Defined in Foreign.C.Types Methods (==) :: CTime -> CTime -> Bool # (/=) :: CTime -> CTime -> Bool #
Eq CUSeconds
Instance details Defined in Foreign.C.Types Methods (==) :: CUSeconds -> CUSeconds -> Bool # (/=) :: CUSeconds -> CUSeconds -> Bool #
Eq CSUSeconds
Instance details Defined in Foreign.C.Types Methods (==) :: CSUSeconds -> CSUSeconds -> Bool # (/=) :: CSUSeconds -> CSUSeconds -> Bool #
Eq CIntPtr
Instance details Defined in Foreign.C.Types Methods (==) :: CIntPtr -> CIntPtr -> Bool # (/=) :: CIntPtr -> CIntPtr -> Bool #
Eq CUIntPtr
Instance details Defined in Foreign.C.Types Methods (==) :: CUIntPtr -> CUIntPtr -> Bool # (/=) :: CUIntPtr -> CUIntPtr -> Bool #
Eq CIntMax
Instance details Defined in Foreign.C.Types Methods (==) :: CIntMax -> CIntMax -> Bool # (/=) :: CIntMax -> CIntMax -> Bool #
Eq CUIntMax
Instance details Defined in Foreign.C.Types Methods (==) :: CUIntMax -> CUIntMax -> Bool # (/=) :: CUIntMax -> CUIntMax -> Bool #
Eq GeneralCategory
Instance details Defined in GHC.Unicode Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool #
Eq SrcLoc
Instance details Defined in GHC.Stack.Types Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq IntSet
Instance details Defined in Data.IntSet.Internal Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Eq LogStr
Instance details Defined in System.Log.FastLogger.LogStr Methods (==) :: LogStr -> LogStr -> Bool # (/=) :: LogStr -> LogStr -> Bool #
Eq Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Eq ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool #
Eq NCon
Instance details Defined in Control.Lens.Internal.PrismTH Methods (==) :: NCon -> NCon -> Bool # (/=) :: NCon -> NCon -> Bool #
Eq TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyVarBndr -> TyVarBndr -> Bool # (/=) :: TyVarBndr -> TyVarBndr -> Bool #
Eq DefName
Instance details Defined in Control.Lens.Internal.FieldTH Methods (==) :: DefName -> DefName -> Bool # (/=) :: DefName -> DefName -> Bool #
Eq LogLevel
Instance details Defined in Control.Monad.Logger Methods (==) :: LogLevel -> LogLevel -> Bool # (/=) :: LogLevel -> LogLevel -> Bool #
Eq Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Eq AddrInfoFlag
Instance details Defined in Network.Socket Methods (==) :: AddrInfoFlag -> AddrInfoFlag -> Bool # (/=) :: AddrInfoFlag -> AddrInfoFlag -> Bool #
Eq AddrInfo
Instance details Defined in Network.Socket Methods (==) :: AddrInfo -> AddrInfo -> Bool # (/=) :: AddrInfo -> AddrInfo -> Bool #
Eq NameInfoFlag
Instance details Defined in Network.Socket Methods (==) :: NameInfoFlag -> NameInfoFlag -> Bool # (/=) :: NameInfoFlag -> NameInfoFlag -> Bool #
Eq Socket
Instance details Defined in Network.Socket.Types Methods (==) :: Socket -> Socket -> Bool # (/=) :: Socket -> Socket -> Bool #
Eq SocketStatus
Instance details Defined in Network.Socket.Types Methods (==) :: SocketStatus -> SocketStatus -> Bool # (/=) :: SocketStatus -> SocketStatus -> Bool #
Eq SocketType
Instance details Defined in Network.Socket.Types Methods (==) :: SocketType -> SocketType -> Bool # (/=) :: SocketType -> SocketType -> Bool #
Eq Family
Instance details Defined in Network.Socket.Types Methods (==) :: Family -> Family -> Bool # (/=) :: Family -> Family -> Bool #
Eq PortNumber
Instance details Defined in Network.Socket.Types Methods (==) :: PortNumber -> PortNumber -> Bool # (/=) :: PortNumber -> PortNumber -> Bool #
Eq SockAddr
Instance details Defined in Network.Socket.Types Methods (==) :: SockAddr -> SockAddr -> Bool # (/=) :: SockAddr -> SockAddr -> Bool #
Eq Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods (==) :: Doc -> Doc -> Bool # (/=) :: Doc -> Doc -> Bool #
Eq TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: TextDetails -> TextDetails -> Bool # (/=) :: TextDetails -> TextDetails -> Bool #
Eq Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Style -> Style -> Bool # (/=) :: Style -> Style -> Bool #
Eq Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Mode -> Mode -> Bool # (/=) :: Mode -> Mode -> Bool #
Eq ByteArray	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.ByteArray Methods (==) :: ByteArray -> ByteArray -> Bool # (/=) :: ByteArray -> ByteArray -> Bool #
Eq Addr
Instance details Defined in Data.Primitive.Types Methods (==) :: Addr -> Addr -> Bool # (/=) :: Addr -> Addr -> Bool #
Eq ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModName -> ModName -> Bool # (/=) :: ModName -> ModName -> Bool #
Eq PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PkgName -> PkgName -> Bool # (/=) :: PkgName -> PkgName -> Bool #
Eq Module
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Eq NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameFlavour -> NameFlavour -> Bool # (/=) :: NameFlavour -> NameFlavour -> Bool #
Eq NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Eq Info
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Eq ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Eq Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Eq Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Eq Body
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Eq Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Eq

HasCtx StatsCtx Source #
Instance details Defined in Preamble.Types.Ctx Methods ctx :: Lens' StatsCtx Ctx Source # cLogger :: Lens' StatsCtx Logger Source # cPreamble :: Lens' StatsCtx Pairs Source #
HasStatsCtx StatsCtx Source #
Instance details Defined in Preamble.Types.Ctx Methods statsCtx :: Lens' StatsCtx StatsCtx Source # scCtx :: Lens' StatsCtx Ctx Source # scLabels :: Lens' StatsCtx Tags Source # scPrefix :: Lens' StatsCtx Text Source # scStat :: Lens' StatsCtx Stat Source #

HasCtx Ctx Source #
Instance details Defined in Preamble.Types.Ctx Methods ctx :: Lens' Ctx Ctx Source # cLogger :: Lens' Ctx Logger Source # cPreamble :: Lens' Ctx Pairs Source #
HasCtx StatsCtx Source #
Instance details Defined in Preamble.Types.Ctx Methods ctx :: Lens' StatsCtx Ctx Source # cLogger :: Lens' StatsCtx Logger Source # cPreamble :: Lens' StatsCtx Pairs Source #

Monad m => MonadReader c (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods ask :: TransT c m c # local :: (c -> c) -> TransT c m a -> TransT c m a # reader :: (c -> a) -> TransT c m a #
MonadBase b m => MonadBase b (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods liftBase :: b α -> TransT c m α #
MonadBaseControl b m => MonadBaseControl b (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Associated Types type StM (TransT c m) a :: * # Methods liftBaseWith :: (RunInBase (TransT c m) b -> b a) -> TransT c m a # restoreM :: StM (TransT c m) a -> TransT c m a #
MonadTrans (TransT c) Source #
Instance details Defined in Preamble.Types.Trans Methods lift :: Monad m => m a -> TransT c m a #
MonadTransControl (TransT c) Source #
Instance details Defined in Preamble.Types.Trans Associated Types type StT (TransT c) a :: * # Methods liftWith :: Monad m => (Run (TransT c) -> m a) -> TransT c m a # restoreT :: Monad m => m (StT (TransT c) a) -> TransT c m a #
Monad m => Monad (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods (>>=) :: TransT c m a -> (a -> TransT c m b) -> TransT c m b # (>>) :: TransT c m a -> TransT c m b -> TransT c m b # return :: a -> TransT c m a # fail :: String -> TransT c m a #
Functor m => Functor (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods fmap :: (a -> b) -> TransT c m a -> TransT c m b # (<$) :: a -> TransT c m b -> TransT c m a #
Applicative m => Applicative (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods pure :: a -> TransT c m a # (<>) :: TransT c m (a -> b) -> TransT c m a -> TransT c m b # liftA2 :: (a -> b -> c0) -> TransT c m a -> TransT c m b -> TransT c m c0 # (>) :: TransT c m a -> TransT c m b -> TransT c m b # (<*) :: TransT c m a -> TransT c m b -> TransT c m a #
MonadIO m => MonadIO (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods liftIO :: IO a -> TransT c m a #
MonadRandom m => MonadRandom (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods getRandomR :: Random a => (a, a) -> TransT c m a # getRandom :: Random a => TransT c m a # getRandomRs :: Random a => (a, a) -> TransT c m [a] # getRandoms :: Random a => TransT c m [a] #
MonadResource m => MonadResource (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods liftResourceT :: ResourceT IO a -> TransT c m a #
MonadThrow m => MonadThrow (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods throwM :: Exception e => e -> TransT c m a #
MonadCatch m => MonadCatch (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods catch :: Exception e => TransT c m a -> (e -> TransT c m a) -> TransT c m a #
MonadMask m => MonadMask (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods mask :: ((forall a. TransT c m a -> TransT c m a) -> TransT c m b) -> TransT c m b # uninterruptibleMask :: ((forall a. TransT c m a -> TransT c m a) -> TransT c m b) -> TransT c m b # generalBracket :: TransT c m a -> (a -> ExitCase b -> TransT c m c0) -> (a -> TransT c m b) -> TransT c m (b, c0) #
MonadIO m => MonadLogger (TransT c m) Source #
Instance details Defined in Preamble.Types.Trans Methods monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> TransT c m () #
type StT (TransT c) a Source #
Instance details Defined in Preamble.Types.Trans type StT (TransT c) a = StT (ReaderT c :: (* -> ) -> -> *) a
type StM (TransT c m) a Source #
Instance details Defined in Preamble.Types.Trans type StM (TransT c m) a = ComposeSt (TransT c) m a

Ctx
Fields _cPreamble :: Pairs Object to encode on every trace line. _cLogger :: Logger Configurable tracing function.

StatsCtx
Fields _scCtx :: Ctx Parent environment. _scLabels :: Tags Tags to append to every stat. _scStat :: Stat Configurable stat function. _scPrefix :: Text Stats prefix.

TransT
Fields unTransT :: LoggingT (ReaderT c m) a LoggingT and ReaderT transformer.