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 {}
- 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 {}
- 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
- data Char
- data Double
- data Float
- data Int
- data Int32
- data Int64
- data Integer
- data Maybe a
- data Ordering
- type Rational = Ratio Integer
- data IO a
- data Word
- data Word8
- data Word32
- data Word64
- data Either a 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
- data AsyncException
- data ArrayException
- data IOErrorType
- interruptible :: IO a -> IO a
- type FilePath = String
- data MaskingState
- userError :: String -> IOError
- data IOException
- type IOError = IOException
- throw :: Exception e => e -> a
- class (Typeable e, Show e) => Exception e where
- data ErrorCall where
- data ArithException
- 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
- (&&) :: 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
- 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
- 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
- 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 {}
- 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 {}
- newtype ReifiedIndexedGetter i s a = IndexedGetter {
- runIndexedGetter :: IndexedGetter i s a
- newtype ReifiedFold s a = Fold {}
- newtype ReifiedIndexedFold i s a = IndexedFold {
- runIndexedFold :: IndexedFold i s a
- newtype ReifiedSetter s t a b = Setter {}
- 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 {}
- type ReifiedIso' s a = ReifiedIso s s a a
- newtype ReifiedPrism s t a b = Prism {}
- 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
- 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.
Instances
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
Instances
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
instance for a transformer
stack over a base monad MonadBaseControl
B
is to write an instance MonadBaseControl B B
for the base monad, and MonadTransControl T
instances for every transformer
T
. Instances for
are then simply implemented using
MonadBaseControl
, ComposeSt
, defaultLiftBaseWith
.defaultRestoreM
Minimal complete definition
Instances
type MonadControl m = (MonadBaseControl IO m, MonadIO m, MonadMask m, MonadRandom m) Source #
MonadControl
type Stat = ByteString -> IO () Source #
Stat
Ctx
Base context, supports tracing.
Constructors
Ctx | |
Fields
|
StatsCtx
Stats context.
Constructors
StatsCtx | |
type MonadCtx c m = (MonadControl m, MonadReader c m, MonadLogger m, MonadCatch m, MonadThrow m, HasCtx c) Source #
Minimal complete definition
type MonadStatsCtx c m = (MonadCtx c m, HasStatsCtx c) Source #
class HasCtx c => HasStatsCtx c where Source #
Minimal complete definition
Monad transformer for reading and logging.
Instances
nullLogger :: Logger Source #
Logger to nowhere.
statsCount :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m () Source #
statsGauge :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m () Source #
statsHistogram :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m () Source #
statsTimer :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m () Source #
statsIncrement :: MonadStatsCtx c m => Text -> Tags -> m () Source #
statsDecrement :: MonadStatsCtx c m => Text -> Tags -> m () Source #
The value of seq a b
is bottom if a
is bottom, and
otherwise equal to b
. In other words, it evaluates the first
argument a
to weak head normal form (WHNF). seq
is usually
introduced to improve performance by avoiding unneeded laziness.
A note on evaluation order: the expression seq a b
does
not guarantee that a
will be evaluated before b
.
The only guarantee given by seq
is that the both a
and b
will be evaluated before seq
returns a value.
In particular, this means that b
may be evaluated before
a
. If you need to guarantee a specific order of evaluation,
you must use the function pseq
from the "parallel" package.
filter :: (a -> Bool) -> [a] -> [a] #
filter
, applied to a predicate and a list, returns the list of
those elements that satisfy the predicate; i.e.,
filter p xs = [ x | x <- xs, p x]
If the first argument evaluates to True
, then the result is the
second argument. Otherwise an AssertionFailed
exception is raised,
containing a String
with the source file and line number of the
call to assert
.
Assertions can normally be turned on or off with a compiler flag
(for GHC, assertions are normally on unless optimisation is turned on
with -O
or the -fignore-asserts
option is given). When assertions are turned off, the first
argument to assert
is ignored, and the second argument is
returned as the result.
($) :: (a -> b) -> a -> b infixr 0 #
Application operator. This operator is redundant, since ordinary
application (f x)
means the same as (f
. However, $
x)$
has
low, right-associative binding precedence, so it sometimes allows
parentheses to be omitted; for example:
f $ g $ h x = f (g (h x))
It is also useful in higher-order situations, such as
,
or map
($
0) xs
.zipWith
($
) fs xs
fromIntegral :: (Integral a, Num b) => a -> b #
general coercion from integral types
realToFrac :: (Real a, Fractional b) => a -> b #
general coercion to fractional types
guard :: Alternative f => Bool -> f () #
Conditional failure of Alternative
computations. Defined by
guard True =pure
() guard False =empty
Examples
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
otherwise. For example:Just
(x `div`
y)
>>> 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.
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
.
Instances
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
andsucc
maxBound
should result in a runtime error.pred
minBound
fromEnum
andtoEnum
should give a runtime error if the result value is not representable in the result type. For example,
is an error.toEnum
7 ::Bool
enumFrom
andenumFromThen
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
Methods
the successor of a value. For numeric types, succ
adds 1.
the predecessor of a value. For numeric types, pred
subtracts 1.
Convert from an 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
.
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
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
.