Copyright | (c) 2021 Tony Zorman |
---|---|
License | BSD3-style (see LICENSE) |
Maintainer | Tony Zorman <soliditsallgood@mailbox.org> |
Safe Haskell | None |
Language | Haskell2010 |
XMonad.Prelude
Contents
Description
Utility functions and re-exports for a more ergonomic developing experience. Users themselves will not find much use here.
Synopsis
- group :: Eq a => [a] -> [[a]]
- (.) :: (b -> c) -> (a -> b) -> a -> c
- data GeneralCategory
- = UppercaseLetter
- | LowercaseLetter
- | TitlecaseLetter
- | ModifierLetter
- | OtherLetter
- | NonSpacingMark
- | SpacingCombiningMark
- | EnclosingMark
- | DecimalNumber
- | LetterNumber
- | OtherNumber
- | ConnectorPunctuation
- | DashPunctuation
- | OpenPunctuation
- | ClosePunctuation
- | InitialQuote
- | FinalQuote
- | OtherPunctuation
- | MathSymbol
- | CurrencySymbol
- | ModifierSymbol
- | OtherSymbol
- | Space
- | LineSeparator
- | ParagraphSeparator
- | Control
- | Format
- | Surrogate
- | PrivateUse
- | NotAssigned
- void :: Functor f => f a -> f ()
- when :: Applicative f => Bool -> f () -> f ()
- filter :: (a -> Bool) -> [a] -> [a]
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- elemIndex :: Eq a => a -> [a] -> Maybe Int
- fromMaybe :: a -> Maybe a -> a
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- findIndex :: (a -> Bool) -> [a] -> Maybe Int
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- fromJust :: HasCallStack => Maybe a -> a
- nub :: Eq a => [a] -> [a]
- delete :: Eq a => a -> [a] -> [a]
- map :: (a -> b) -> [a] -> [b]
- (<&>) :: Functor f => f a -> (a -> b) -> f b
- const :: a -> b -> a
- id :: a -> a
- otherwise :: Bool
- ($) :: (a -> b) -> a -> b
- listToMaybe :: [a] -> Maybe a
- sort :: Ord a => [a] -> [a]
- drop :: Int -> [a] -> [a]
- class Foldable (t :: Type -> Type) where
- fold :: Monoid m => t m -> m
- foldMap :: Monoid m => (a -> m) -> t a -> m
- foldMap' :: Monoid m => (a -> m) -> t a -> m
- foldr :: (a -> b -> b) -> b -> t a -> b
- foldr' :: (a -> b -> b) -> b -> t a -> b
- foldl :: (b -> a -> b) -> b -> t a -> b
- foldl' :: (b -> a -> b) -> b -> t a -> b
- foldr1 :: (a -> a -> a) -> t a -> a
- foldl1 :: (a -> a -> a) -> t a -> a
- null :: t a -> Bool
- length :: t a -> Int
- elem :: Eq a => a -> t a -> Bool
- maximum :: Ord a => t a -> a
- minimum :: Ord a => t a -> a
- sum :: Num a => t a -> a
- product :: Num a => t a -> a
- reverse :: [a] -> [a]
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- insert :: Ord a => a -> [a] -> [a]
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- class Applicative f => Alternative (f :: Type -> Type) where
- join :: Monad m => m (m a) -> m a
- guard :: Alternative f => Bool -> f ()
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- partition :: (a -> Bool) -> [a] -> ([a], [a])
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- (\\) :: Eq a => [a] -> [a] -> [a]
- isPrefixOf :: Eq a => [a] -> [a] -> Bool
- isAlphaNum :: Char -> Bool
- isAscii :: Char -> Bool
- newtype All = All {}
- fix :: (a -> a) -> a
- class Applicative m => Monad (m :: Type -> Type) where
- catMaybes :: [Maybe a] -> [a]
- isInfixOf :: Eq a => [a] -> [a] -> Bool
- toUpper :: Char -> Char
- bool :: a -> a -> Bool -> a
- for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
- maybeToList :: Maybe a -> [a]
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- newtype Endo a = Endo {
- appEndo :: a -> a
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- ord :: Char -> Int
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- class Functor f => Applicative (f :: Type -> Type) where
- chr :: Int -> Char
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- intersect :: Eq a => [a] -> [a] -> [a]
- ap :: Monad m => m (a -> b) -> m a -> m b
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- unless :: Applicative f => Bool -> f () -> f ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- data Maybe a
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- singleton :: a -> [a]
- newtype Const a (b :: k) = Const {
- getConst :: a
- class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
- data Bool
- data Char
- class Functor (f :: Type -> Type) where
- unzip :: [(a, b)] -> ([a], [b])
- class Semigroup a => Monoid a where
- head :: HasCallStack => [a] -> a
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- (!!) :: HasCallStack => [a] -> Int -> a
- traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- isSuffixOf :: Eq a => [a] -> [a] -> Bool
- isUpper :: Char -> Bool
- class Monad m => MonadFail (m :: Type -> Type) where
- and :: Foldable t => t Bool -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- concat :: Foldable t => t [a] -> [a]
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- maybe :: b -> (a -> b) -> Maybe a -> b
- lines :: String -> [String]
- unlines :: [String] -> String
- unwords :: [String] -> String
- words :: String -> [String]
- (++) :: [a] -> [a] -> [a]
- (<>) :: Semigroup a => a -> a -> a
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- flip :: (a -> b -> c) -> b -> a -> c
- break :: (a -> Bool) -> [a] -> ([a], [a])
- cycle :: HasCallStack => [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- init :: HasCallStack => [a] -> [a]
- iterate :: (a -> a) -> a -> [a]
- last :: HasCallStack => [a] -> a
- repeat :: a -> [a]
- replicate :: Int -> a -> [a]
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- span :: (a -> Bool) -> [a] -> ([a], [a])
- splitAt :: Int -> [a] -> ([a], [a])
- tail :: HasCallStack => [a] -> [a]
- take :: Int -> [a] -> [a]
- takeWhile :: (a -> Bool) -> [a] -> [a]
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- zip :: [a] -> [b] -> [(a, b)]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- (&&) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- newtype Any = Any {}
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- liftA :: Applicative f => (a -> b) -> f a -> f b
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- liftM :: Monad m => (a1 -> r) -> m a1 -> 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
- intToDigit :: Int -> Char
- newtype Product a = Product {
- getProduct :: a
- newtype Sum a = Sum {
- getSum :: a
- newtype Ap (f :: k -> Type) (a :: k) = Ap {
- getAp :: f a
- union :: Eq a => [a] -> [a] -> [a]
- nubBy :: (a -> a -> Bool) -> [a] -> [a]
- deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- showLitChar :: Char -> ShowS
- iterate' :: (a -> a) -> a -> [a]
- scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a
- uncons :: [a] -> Maybe (a, [a])
- unsnoc :: [a] -> Maybe ([a], a)
- newtype First a = First {}
- newtype Last a = Last {}
- newtype Alt (f :: k -> Type) (a :: k) = Alt {
- getAlt :: f a
- newtype Dual a = Dual {
- getDual :: a
- foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- isDigit :: Char -> Bool
- ($>) :: Functor f => f a -> b -> f b
- forever :: Applicative f => f a -> f b
- isSpace :: Char -> Bool
- optional :: Alternative f => f a -> f (Maybe a)
- lexLitChar :: ReadS String
- readLitChar :: ReadS Char
- generalCategory :: Char -> GeneralCategory
- isAlpha :: Char -> Bool
- deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- dropWhileEnd :: (a -> Bool) -> [a] -> [a]
- elemIndices :: Eq a => a -> [a] -> [Int]
- findIndices :: (a -> Bool) -> [a] -> [Int]
- genericDrop :: Integral i => i -> [a] -> [a]
- genericIndex :: Integral i => [a] -> i -> a
- genericLength :: Num i => [a] -> i
- genericReplicate :: Integral i => i -> a -> [a]
- genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- genericTake :: Integral i => i -> [a] -> [a]
- inits :: [a] -> [[a]]
- insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- intercalate :: [a] -> [[a]] -> [a]
- intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- intersperse :: a -> [a] -> [a]
- permutations :: [a] -> [[a]]
- stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
- subsequences :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- transpose :: [[a]] -> [[a]]
- unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
- unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
- unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- replicateM_ :: Applicative m => Int -> m a -> m ()
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- newtype WrappedArrow (a :: Type -> Type -> Type) b c = WrapArrow {
- unwrapArrow :: a b c
- newtype WrappedMonad (m :: Type -> Type) a = WrapMonad {
- unwrapMonad :: m a
- newtype ZipList a = ZipList {
- getZipList :: [a]
- isAsciiLower :: Char -> Bool
- isAsciiUpper :: Char -> Bool
- isControl :: Char -> Bool
- isHexDigit :: Char -> Bool
- isLatin1 :: Char -> Bool
- isLower :: Char -> Bool
- isLowerCase :: Char -> Bool
- isOctDigit :: Char -> Bool
- isPrint :: Char -> Bool
- isPunctuation :: Char -> Bool
- isSymbol :: Char -> Bool
- isUpperCase :: Char -> Bool
- toLower :: Char -> Char
- toTitle :: Char -> Char
- digitToInt :: Char -> Int
- isLetter :: Char -> Bool
- isMark :: Char -> Bool
- isNumber :: Char -> Bool
- isSeparator :: Char -> Bool
- (&) :: a -> (a -> b) -> b
- applyWhen :: Bool -> (a -> a) -> a -> a
- fmapDefault :: Traversable t => (a -> b) -> t a -> t b
- foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
- forAccumM :: (Monad m, Traversable t) => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b)
- mapAccumM :: (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b)
- fi :: (Integral a, Num b) => a -> b
- chunksOf :: Int -> [a] -> [[a]]
- (.:) :: (a -> b) -> (c -> d -> a) -> c -> d -> b
- (!?) :: [a] -> Int -> Maybe a
- data NonEmpty a = a :| [a]
- notEmpty :: HasCallStack => [a] -> NonEmpty a
- safeGetWindowAttributes :: Window -> X (Maybe WindowAttributes)
- mkAbsolutePath :: MonadIO m => FilePath -> m FilePath
- findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
- keyToString :: (KeyMask, KeySym) -> String
- keymaskToString :: KeyMask -> KeyMask -> String
- cleanKeyMask :: X (KeyMask -> KeyMask)
- regularKeys :: [(String, KeySym)]
- allSpecialKeys :: [(String, KeySym)]
- specialKeys :: [(String, KeySym)]
- multimediaKeys :: [(String, KeySym)]
- functionKeys :: [(String, KeySym)]
- type WindowScreen = Screen WorkspaceId (Layout Window) Window ScreenId ScreenDetail
- data Stream a = !a :~ (Stream a)
- (+~) :: [a] -> Stream a -> Stream a
- cycleS :: NonEmpty a -> Stream a
- takeS :: Int -> Stream a -> [a]
- toList :: IsList l => l -> [Item l]
- fromList :: IsList l => [Item l] -> l
Documentation
data GeneralCategory #
Constructors
Instances
Bounded GeneralCategory | |||||
Defined in GHC.Unicode | |||||
Enum GeneralCategory | |||||
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] # | |||||
Generic GeneralCategory | |||||
Defined in GHC.Generics Associated Types
Methods from :: GeneralCategory -> Rep GeneralCategory x to :: Rep GeneralCategory x -> GeneralCategory | |||||
Ix GeneralCategory | |||||
Defined in GHC.Unicode Methods range :: (GeneralCategory, GeneralCategory) -> [GeneralCategory] index :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int unsafeIndex :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int inRange :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Bool rangeSize :: (GeneralCategory, GeneralCategory) -> Int unsafeRangeSize :: (GeneralCategory, GeneralCategory) -> Int | |||||
Read GeneralCategory | |||||
Defined in GHC.Read Methods readsPrec :: Int -> ReadS GeneralCategory # readList :: ReadS [GeneralCategory] # readPrec :: ReadPrec GeneralCategory readListPrec :: ReadPrec [GeneralCategory] | |||||
Show GeneralCategory | |||||
Defined in GHC.Unicode Methods showsPrec :: Int -> GeneralCategory -> ShowS # show :: GeneralCategory -> String # showList :: [GeneralCategory] -> ShowS # | |||||
Eq GeneralCategory | |||||
Defined in GHC.Unicode Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool # | |||||
Ord GeneralCategory | |||||
Defined in GHC.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering # (<) :: GeneralCategory -> GeneralCategory -> Bool # (<=) :: GeneralCategory -> GeneralCategory -> Bool # (>) :: GeneralCategory -> GeneralCategory -> Bool # (>=) :: GeneralCategory -> GeneralCategory -> Bool # max :: GeneralCategory -> GeneralCategory -> GeneralCategory # min :: GeneralCategory -> GeneralCategory -> GeneralCategory # | |||||
type Rep GeneralCategory | |||||
Defined in GHC.Generics type Rep GeneralCategory = D1 ('MetaData "GeneralCategory" "GHC.Unicode" "base" 'False) ((((C1 ('MetaCons "UppercaseLetter" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LowercaseLetter" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TitlecaseLetter" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ModifierLetter" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OtherLetter" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NonSpacingMark" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SpacingCombiningMark" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "EnclosingMark" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DecimalNumber" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LetterNumber" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OtherNumber" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ConnectorPunctuation" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DashPunctuation" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "OpenPunctuation" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ClosePunctuation" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "InitialQuote" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FinalQuote" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OtherPunctuation" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MathSymbol" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CurrencySymbol" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ModifierSymbol" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OtherSymbol" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "Space" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LineSeparator" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ParagraphSeparator" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Control" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Format" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Surrogate" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PrivateUse" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NotAssigned" 'PrefixI 'False) (U1 :: Type -> Type)))))) |
when :: Applicative f => Bool -> f () -> f () #
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f () #
listToMaybe :: [a] -> Maybe a #
class Foldable (t :: Type -> Type) where #
Methods
fold :: Monoid m => t m -> m #
foldMap :: Monoid m => (a -> m) -> t a -> m #
foldMap' :: Monoid m => (a -> m) -> t a -> m #
foldr :: (a -> b -> b) -> b -> t a -> b #
foldr' :: (a -> b -> b) -> b -> t a -> b #
foldl :: (b -> a -> b) -> b -> t a -> b #
foldl' :: (b -> a -> b) -> b -> t a -> b #
foldr1 :: (a -> a -> a) -> t a -> a #
foldl1 :: (a -> a -> a) -> t a -> a #
elem :: Eq a => a -> t a -> Bool #
maximum :: Ord a => t a -> a #
Instances
Foldable ZipList | |
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
Foldable Complex | |
Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m # foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldMap' :: Monoid m => (a -> m) -> Complex a -> m # foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b # foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b # foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
Foldable Identity | |
Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
Foldable First | |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Down | |
Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m # foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m # foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b # foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b # foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # | |
Foldable First | |
Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | |
Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Max | |
Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m # foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m # foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b # foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b # foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # toList :: Max a -> [a] elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
Foldable Min | |
Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m # foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m # foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b # foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b # foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # toList :: Min a -> [a] elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
Foldable Dual | |
Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m # foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b # foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
Foldable Product | |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
Foldable Sum | |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
Foldable NonEmpty | |
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
Foldable Par1 | |
Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m # foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m # foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b # foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b # foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # toList :: Par1 a -> [a] elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
Foldable SCC | |
Defined in Data.Graph Methods fold :: Monoid m => SCC m -> m # foldMap :: Monoid m => (a -> m) -> SCC a -> m # foldMap' :: Monoid m => (a -> m) -> SCC a -> m # foldr :: (a -> b -> b) -> b -> SCC a -> b # foldr' :: (a -> b -> b) -> b -> SCC a -> b # foldl :: (b -> a -> b) -> b -> SCC a -> b # foldl' :: (b -> a -> b) -> b -> SCC a -> b # foldr1 :: (a -> a -> a) -> SCC a -> a # foldl1 :: (a -> a -> a) -> SCC a -> a # toList :: SCC a -> [a] elem :: Eq a => a -> SCC a -> Bool # maximum :: Ord a => SCC a -> a # | |
Foldable IntMap | |
Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m # foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m # foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b # foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b # foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # toList :: IntMap a -> [a] elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # | |
Foldable Digit | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m # foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldMap' :: Monoid m => (a -> m) -> Digit a -> m # foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b # foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b # foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # toList :: Digit a -> [a] elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # | |
Foldable Elem | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m # foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldMap' :: Monoid m => (a -> m) -> Elem a -> m # foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b # foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b # foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # toList :: Elem a -> [a] elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # | |
Foldable FingerTree | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m # foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m # foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b # foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b # foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # | |
Foldable Node | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m # foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m # foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b # foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b # foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # toList :: Node a -> [a] elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
Foldable Seq | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m # foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # | |
Foldable ViewL | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m # foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m # foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b # foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b # foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # toList :: ViewL a -> [a] elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # | |
Foldable ViewR | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m # foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m # foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b # foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b # foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # toList :: ViewR a -> [a] elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # | |
Foldable Set | |
Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m # foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m # foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b # foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b # foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
Foldable Tree | |
Defined in Data.Tree Methods fold :: Monoid m => Tree m -> m # foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldMap' :: Monoid m => (a -> m) -> Tree a -> m # foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b # foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b # foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # toList :: Tree a -> [a] elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
Foldable TyVarBndr | |
Defined in Language.Haskell.TH.Syntax Methods fold :: Monoid m => TyVarBndr m -> m # foldMap :: Monoid m => (a -> m) -> TyVarBndr a -> m # foldMap' :: Monoid m => (a -> m) -> TyVarBndr a -> m # foldr :: (a -> b -> b) -> b -> TyVarBndr a -> b # foldr' :: (a -> b -> b) -> b -> TyVarBndr a -> b # foldl :: (b -> a -> b) -> b -> TyVarBndr a -> b # foldl' :: (b -> a -> b) -> b -> TyVarBndr a -> b # foldr1 :: (a -> a -> a) -> TyVarBndr a -> a # foldl1 :: (a -> a -> a) -> TyVarBndr a -> a # toList :: TyVarBndr a -> [a] length :: TyVarBndr a -> Int # elem :: Eq a => a -> TyVarBndr a -> Bool # maximum :: Ord a => TyVarBndr a -> a # minimum :: Ord a => TyVarBndr a -> a # | |
Foldable Directories' | |
Defined in XMonad.Core Methods fold :: Monoid m => Directories' m -> m # foldMap :: Monoid m => (a -> m) -> Directories' a -> m # foldMap' :: Monoid m => (a -> m) -> Directories' a -> m # foldr :: (a -> b -> b) -> b -> Directories' a -> b # foldr' :: (a -> b -> b) -> b -> Directories' a -> b # foldl :: (b -> a -> b) -> b -> Directories' a -> b # foldl' :: (b -> a -> b) -> b -> Directories' a -> b # foldr1 :: (a -> a -> a) -> Directories' a -> a # foldl1 :: (a -> a -> a) -> Directories' a -> a # toList :: Directories' a -> [a] null :: Directories' a -> Bool # length :: Directories' a -> Int # elem :: Eq a => a -> Directories' a -> Bool # maximum :: Ord a => Directories' a -> a # minimum :: Ord a => Directories' a -> a # sum :: Num a => Directories' a -> a # product :: Num a => Directories' a -> a # | |
Foldable Stack | |
Defined in XMonad.StackSet Methods fold :: Monoid m => Stack m -> m # foldMap :: Monoid m => (a -> m) -> Stack a -> m # foldMap' :: Monoid m => (a -> m) -> Stack a -> m # foldr :: (a -> b -> b) -> b -> Stack a -> b # foldr' :: (a -> b -> b) -> b -> Stack a -> b # foldl :: (b -> a -> b) -> b -> Stack a -> b # foldl' :: (b -> a -> b) -> b -> Stack a -> b # foldr1 :: (a -> a -> a) -> Stack a -> a # foldl1 :: (a -> a -> a) -> Stack a -> a # toList :: Stack a -> [a] elem :: Eq a => a -> Stack a -> Bool # maximum :: Ord a => Stack a -> a # minimum :: Ord a => Stack a -> a # | |
Foldable Cursors Source # | |
Defined in XMonad.Actions.WorkspaceCursors Methods fold :: Monoid m => Cursors m -> m # foldMap :: Monoid m => (a -> m) -> Cursors a -> m # foldMap' :: Monoid m => (a -> m) -> Cursors a -> m # foldr :: (a -> b -> b) -> b -> Cursors a -> b # foldr' :: (a -> b -> b) -> b -> Cursors a -> b # foldl :: (b -> a -> b) -> b -> Cursors a -> b # foldl' :: (b -> a -> b) -> b -> Cursors a -> b # foldr1 :: (a -> a -> a) -> Cursors a -> a # foldl1 :: (a -> a -> a) -> Cursors a -> a # elem :: Eq a => a -> Cursors a -> Bool # maximum :: Ord a => Cursors a -> a # minimum :: Ord a => Cursors a -> a # | |
Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Foldable Solo | |
Defined in Data.Foldable Methods fold :: Monoid m => Solo m -> m # foldMap :: Monoid m => (a -> m) -> Solo a -> m # foldMap' :: Monoid m => (a -> m) -> Solo a -> m # foldr :: (a -> b -> b) -> b -> Solo a -> b # foldr' :: (a -> b -> b) -> b -> Solo a -> b # foldl :: (b -> a -> b) -> b -> Solo a -> b # foldl' :: (b -> a -> b) -> b -> Solo a -> b # foldr1 :: (a -> a -> a) -> Solo a -> a # foldl1 :: (a -> a -> a) -> Solo a -> a # toList :: Solo a -> [a] elem :: Eq a => a -> Solo a -> Bool # maximum :: Ord a => Solo a -> a # | |
Foldable [] | |
Defined in Data.Foldable Methods fold :: Monoid m => [m] -> m # foldMap :: Monoid m => (a -> m) -> [a] -> m # foldMap' :: Monoid m => (a -> m) -> [a] -> m # foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b # foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b # foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Foldable (Proxy :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m # foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b # foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b # foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # toList :: Proxy a -> [a] elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |
Foldable (Arg a) | |
Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m # foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # toList :: Arg a a0 -> [a0] elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
Foldable (Array i) | |
Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m # foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m # foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b # foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b # foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
Foldable (U1 :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => U1 m -> m # foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m # foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b # foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b # foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # toList :: U1 a -> [a] elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
Foldable (UAddr :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m # foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m # foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b # foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b # foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # toList :: UAddr a -> [a] elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # | |
Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
Foldable (UDouble :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
Foldable (UFloat :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
Foldable (UInt :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
Foldable (UWord :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m # foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m # foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b # foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b # foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |
Foldable (V1 :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => V1 m -> m # foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b # foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b # foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
Foldable (Map k) | |
Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m # foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m # foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b # foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b # foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # toList :: Map k a -> [a] elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b # foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
Foldable (History k) Source # | |
Defined in XMonad.Util.History Methods fold :: Monoid m => History k m -> m # foldMap :: Monoid m => (a -> m) -> History k a -> m # foldMap' :: Monoid m => (a -> m) -> History k a -> m # foldr :: (a -> b -> b) -> b -> History k a -> b # foldr' :: (a -> b -> b) -> b -> History k a -> b # foldl :: (b -> a -> b) -> b -> History k a -> b # foldl' :: (b -> a -> b) -> b -> History k a -> b # foldr1 :: (a -> a -> a) -> History k a -> a # foldl1 :: (a -> a -> a) -> History k a -> a # length :: History k a -> Int # elem :: Eq a => a -> History k a -> Bool # maximum :: Ord a => History k a -> a # minimum :: Ord a => History k a -> a # | |
Foldable ((,) a) | |
Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m # foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # toList :: (a, a0) -> [a0] elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
Foldable f => Foldable (Ap f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m # foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m # foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b # foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b # foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |
Foldable f => Foldable (Alt f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m # foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m # foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b # foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b # foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # | |
Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m # foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m # foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b # foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b # foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # toList :: Rec1 f a -> [a] elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # | |
Foldable f => Foldable (Backwards f) | |
Defined in Control.Applicative.Backwards Methods fold :: Monoid m => Backwards f m -> m # foldMap :: Monoid m => (a -> m) -> Backwards f a -> m # foldMap' :: Monoid m => (a -> m) -> Backwards f a -> m # foldr :: (a -> b -> b) -> b -> Backwards f a -> b # foldr' :: (a -> b -> b) -> b -> Backwards f a -> b # foldl :: (b -> a -> b) -> b -> Backwards f a -> b # foldl' :: (b -> a -> b) -> b -> Backwards f a -> b # foldr1 :: (a -> a -> a) -> Backwards f a -> a # foldl1 :: (a -> a -> a) -> Backwards f a -> a # toList :: Backwards f a -> [a] null :: Backwards f a -> Bool # length :: Backwards f a -> Int # elem :: Eq a => a -> Backwards f a -> Bool # maximum :: Ord a => Backwards f a -> a # minimum :: Ord a => Backwards f a -> a # | |
Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
Foldable f => Foldable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m # foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m # foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b # foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b # foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # | |
Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b # foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Strict Methods fold :: Monoid m => WriterT w f m -> m # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b # foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
(Foldable f, Foldable g) => Foldable (Product f g) | |
Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m # foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m # foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b # foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b # foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # | |
(Foldable f, Foldable g) => Foldable (Sum f g) | |
Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m # foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m # foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b # foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b # foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # toList :: Sum f g a -> [a] elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # | |
(Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :*: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldr1 :: (a -> a -> a) -> (f :*: g) a -> a # foldl1 :: (a -> a -> a) -> (f :*: g) a -> a # toList :: (f :*: g) a -> [a] length :: (f :*: g) a -> Int # elem :: Eq a => a -> (f :*: g) a -> Bool # maximum :: Ord a => (f :*: g) a -> a # minimum :: Ord a => (f :*: g) a -> a # | |
(Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # | |
Foldable (K1 i c :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m # foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m # foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b # foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b # foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # toList :: K1 i c a -> [a] elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # minimum :: Ord a => K1 i c a -> a # | |
(Foldable f, Foldable g) => Foldable (Compose f g) | |
Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # | |
(Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # | |
Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b # foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b # foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # toList :: M1 i c f a -> [a] elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # |
class Applicative f => Alternative (f :: Type -> Type) where #
Instances
guard :: Alternative f => Bool -> f () #
isPrefixOf :: Eq a => [a] -> [a] -> Bool #
isAlphaNum :: Char -> Bool #
Instances
Data All | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All dataTypeOf :: All -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c All) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) gmapT :: (forall b. Data b => b -> b) -> All -> All gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r gmapQ :: (forall d. Data d => d -> u) -> All -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All | |||||
Monoid All | |||||
Semigroup All | |||||
Bounded All | |||||
Generic All | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Read All | |||||
Show All | |||||
Default All | |||||
Defined in Data.Default.Class | |||||
NFData All | |||||
Defined in Control.DeepSeq | |||||
Eq All | |||||
Ord All | |||||
type Rep All | |||||
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad Complex | |
Monad Identity | |
Monad First | |
Monad Last | |
Monad Down | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad Dual | |
Monad Product | |
Monad Sum | |
Monad NonEmpty | |
Monad STM | |
Monad NoIO | |
Monad Par1 | |
Monad P | |
Monad ReadP | |
Monad ReadPrec | |
Monad Put | |
Monad Seq | |
Monad Tree | |
Monad IO | |
Monad Q | |
Monad Query | |
Monad X | |
Monad FocusQuery Source # | |
Defined in XMonad.Hooks.Focus Methods (>>=) :: FocusQuery a -> (a -> FocusQuery b) -> FocusQuery b # (>>) :: FocusQuery a -> FocusQuery b -> FocusQuery b # return :: a -> FocusQuery a # | |
Monad Parser Source # | |
Monad PureX Source # | |
Monad Maybe | |
Monad Solo | |
Monad [] | |
Monad m => Monad (WrappedMonad m) | |
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Either e) | |
Monad (Proxy :: Type -> Type) | |
Monad (U1 :: Type -> Type) | |
Monad (ST s) | |
Monad (SetM s) | |
Monad m => Monad (MaybeT m) | |
Monad (TwoD a) Source # | |
Monad m => Monad (Invisible m) Source # | |
Monad (StateQuery s) Source # | |
Defined in XMonad.Util.WindowState Methods (>>=) :: StateQuery s a -> (a -> StateQuery s b) -> StateQuery s b # (>>) :: StateQuery s a -> StateQuery s b -> StateQuery s b # return :: a -> StateQuery s a # | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (Kleisli m a) | |
Monad f => Monad (Ap f) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Rec1 f) | |
(Applicative f, Monad f) => Monad (WhenMissing f x) | |
Monad (t m) => Monad (LiftingAccum t m) | |
Monad (t m) => Monad (LiftingSelect t m) | |
(Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
Monad m => Monad (ExceptT e m) | |
Monad m => Monad (IdentityT m) | |
Monad m => Monad (ReaderT r m) | |
Monad m => Monad (SelectT r m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
(Monad f, Monad g) => Monad (Product f g) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monad f, Applicative f) => Monad (WhenMatched f x y) | |
(Applicative f, Monad f) => Monad (WhenMissing f k x) | |
Monad (ContT r m) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
Monad ((->) r) | |
Monad f => Monad (M1 i c f) | |
(Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
Monad m => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) #
maybeToList :: Maybe a -> [a] #
Instances
Monoid (Endo a) | |||||
Semigroup (Endo a) | |||||
Generic (Endo a) | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Default (Endo a) | |||||
Defined in Data.Default.Class | |||||
type Rep (Endo a) | |||||
Defined in Data.Semigroup.Internal |
asum :: (Foldable t, Alternative f) => t (f a) -> f a #
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative ZipList | |
Applicative Complex | |
Applicative Identity | |
Applicative First | |
Applicative Last | |
Applicative Down | |
Applicative First | |
Applicative Last | |
Applicative Max | |
Applicative Min | |
Applicative Dual | |
Applicative Product | |
Applicative Sum | |
Applicative NonEmpty | |
Applicative STM | |
Applicative NoIO | |
Applicative Par1 | |
Applicative P | |
Applicative ReadP | |
Applicative ReadPrec | |
Applicative Put | |
Applicative Seq | |
Applicative Tree | |
Applicative IO | |
Applicative Q | |
Applicative Query | |
Applicative X | |
Applicative FocusQuery Source # | |
Defined in XMonad.Hooks.Focus Methods pure :: a -> FocusQuery a # (<*>) :: FocusQuery (a -> b) -> FocusQuery a -> FocusQuery b # liftA2 :: (a -> b -> c) -> FocusQuery a -> FocusQuery b -> FocusQuery c # (*>) :: FocusQuery a -> FocusQuery b -> FocusQuery b # (<*) :: FocusQuery a -> FocusQuery b -> FocusQuery a # | |
Applicative Parser Source # | |
Applicative PureX Source # | |
Applicative Maybe | |
Applicative Solo | |
Applicative [] | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
Arrow a => Applicative (ArrowMonad a) | |
Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 # | |
Applicative (Either e) | |
Applicative (Proxy :: Type -> Type) | |
Applicative (U1 :: Type -> Type) | |
Applicative (ST s) | |
Applicative (SetM s) | |
(Functor m, Monad m) => Applicative (MaybeT m) | |
Applicative (TwoD a) Source # | |
Applicative m => Applicative (Invisible m) Source # | |
Defined in XMonad.Util.Invisible | |
Applicative (StateQuery s) Source # | |
Defined in XMonad.Util.WindowState Methods pure :: a -> StateQuery s a # (<*>) :: StateQuery s (a -> b) -> StateQuery s a -> StateQuery s b # liftA2 :: (a -> b -> c) -> StateQuery s a -> StateQuery s b -> StateQuery s c # (*>) :: StateQuery s a -> StateQuery s b -> StateQuery s b # (<*) :: StateQuery s a -> StateQuery s b -> StateQuery s a # | |
Monoid a => Applicative ((,) a) | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
Applicative m => Applicative (Kleisli m a) | |
Defined in Control.Arrow | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Applicative f => Applicative (Ap f) | |
Applicative f => Applicative (Alt f) | |
(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | |
Defined in GHC.Generics Methods pure :: a -> Generically1 f a # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a # | |
Applicative f => Applicative (Rec1 f) | |
(Applicative f, Monad f) => Applicative (WhenMissing f x) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a # | |
Applicative (t m) => Applicative (LiftingAccum t m) | |
Defined in Control.Monad.Accum Methods pure :: a -> LiftingAccum t m a # (<*>) :: LiftingAccum t m (a -> b) -> LiftingAccum t m a -> LiftingAccum t m b # liftA2 :: (a -> b -> c) -> LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m c # (*>) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m b # (<*) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m a # | |
Applicative (t m) => Applicative (LiftingSelect t m) | |
Defined in Control.Monad.Select Methods pure :: a -> LiftingSelect t m a # (<*>) :: LiftingSelect t m (a -> b) -> LiftingSelect t m a -> LiftingSelect t m b # liftA2 :: (a -> b -> c) -> LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m c # (*>) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m b # (<*) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m a # | |
Applicative f => Applicative (Backwards f) | |
Defined in Control.Applicative.Backwards | |
(Monoid w, Functor m, Monad m) => Applicative (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
(Functor m, Monad m) => Applicative (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
(Functor m, Monad m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(Monoid a, Monoid b) => Applicative ((,,) a b) | |
(Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
(Applicative f, Applicative g) => Applicative (f :*: g) | |
Monoid c => Applicative (K1 i c :: Type -> Type) | |
(Monad f, Applicative f) => Applicative (WhenMatched f x y) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a # | |
(Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a # | |
Applicative (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Base | |
Applicative ((->) r) | |
(Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
(Applicative f, Applicative g) => Applicative (f :.: g) | |
Applicative f => Applicative (M1 i c f) | |
(Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a # | |
(Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict |
unless :: Applicative f => Bool -> f () -> f () #
replicateM :: Applicative m => Int -> m a -> m [a] #
Instances
MonadFail Maybe | |||||
Defined in Control.Monad.Fail | |||||
MonadFix Maybe | |||||
Defined in Control.Monad.Fix | |||||
MonadZip Maybe | |||||
Foldable Maybe | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |||||
Eq1 Maybe | |||||
Ord1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |||||
Read1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] | |||||
Show1 Maybe | |||||
Defined in Data.Functor.Classes | |||||
Traversable Maybe | |||||
Alternative Maybe | |||||
Applicative Maybe | |||||
Functor Maybe | |||||
Monad Maybe | |||||
MonadPlus Maybe | |||||
NFData1 Maybe | |||||
Defined in Control.DeepSeq | |||||
Generic1 Maybe | |||||
Defined in GHC.Generics Associated Types
| |||||
MonadError () Maybe | |||||
Defined in Control.Monad.Error.Class | |||||
Lift a => Lift (Maybe a :: Type) | |||||
Data a => Data (Maybe a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) dataTypeOf :: Maybe a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) | |||||
Semigroup a => Monoid (Maybe a) | |||||
Semigroup a => Semigroup (Maybe a) | |||||
Generic (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
SingKind a => SingKind (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
Read a => Read (Maybe a) | |||||
Show a => Show (Maybe a) | |||||
Default (Maybe a) | |||||
Defined in Data.Default.Class | |||||
NFData a => NFData (Maybe a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (Maybe a) | |||||
Ord a => Ord (Maybe a) | |||||
PPrint a => PPrint (Maybe a) Source # | |||||
SingI ('Nothing :: Maybe a) | |||||
Defined in GHC.Generics | |||||
(Show s, Read s, Typeable s) => MonadState (Maybe s) (StateQuery s) Source # | Instance of MonadState for StateQuery. | ||||
Defined in XMonad.Util.WindowState Methods get :: StateQuery s (Maybe s) # put :: Maybe s -> StateQuery s () # state :: (Maybe s -> (a, Maybe s)) -> StateQuery s a # | |||||
SingI a2 => SingI ('Just a2 :: Maybe a1) | |||||
Defined in GHC.Generics | |||||
type Rep1 Maybe | |||||
type DemoteRep (Maybe a) | |||||
Defined in GHC.Generics | |||||
type Rep (Maybe a) | |||||
Defined in GHC.Generics | |||||
data Sing (b :: Maybe a) | |||||
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #
Minimal complete definition
Nothing
Instances
Instances
Generic1 (Const a :: k -> Type) | |||||
Defined in Data.Functor.Const Associated Types
| |||||
Bifoldable (Const :: Type -> Type -> Type) | |||||
Bifoldable1 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Bifoldable1 | |||||
Bifunctor (Const :: Type -> Type -> Type) | |||||
Bitraversable (Const :: Type -> Type -> Type) | |||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) | |||||
Eq2 (Const :: Type -> Type -> Type) | |||||
Ord2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Functor.Classes | |||||
Read2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] | |||||
Show2 (Const :: Type -> Type -> Type) | |||||
NFData2 (Const :: Type -> Type -> Type) | |||||
Defined in Control.DeepSeq | |||||
Foldable (Const m :: Type -> Type) | |||||
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |||||
Eq a => Eq1 (Const a :: Type -> Type) | |||||
Ord a => Ord1 (Const a :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering | |||||
Read a => Read1 (Const a :: Type -> Type) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] | |||||
Show a => Show1 (Const a :: Type -> Type) | |||||
Defined in Data.Functor.Classes | |||||
Contravariant (Const a :: Type -> Type) | |||||
Traversable (Const m :: Type -> Type) | |||||
Monoid m => Applicative (Const m :: Type -> Type) | |||||
Functor (Const m :: Type -> Type) | |||||
NFData a => NFData1 (Const a :: Type -> Type) | |||||
Defined in Control.DeepSeq | |||||
(Typeable k, Data a, Typeable b) => Data (Const a b) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) toConstr :: Const a b -> Constr dataTypeOf :: Const a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) | |||||
IsString a => IsString (Const a b) | |||||
Defined in Data.String Methods fromString :: String -> Const a b | |||||
Storable a => Storable (Const a b) | |||||
Defined in Data.Functor.Const | |||||
Monoid a => Monoid (Const a b) | |||||
Semigroup a => Semigroup (Const a b) | |||||
Bits a => Bits (Const a b) | |||||
Defined in Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b (.|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b complement :: Const a b -> Const a b shift :: Const a b -> Int -> Const a b rotate :: Const a b -> Int -> Const a b setBit :: Const a b -> Int -> Const a b clearBit :: Const a b -> Int -> Const a b complementBit :: Const a b -> Int -> Const a b testBit :: Const a b -> Int -> Bool bitSizeMaybe :: Const a b -> Maybe Int shiftL :: Const a b -> Int -> Const a b unsafeShiftL :: Const a b -> Int -> Const a b shiftR :: Const a b -> Int -> Const a b unsafeShiftR :: Const a b -> Int -> Const a b rotateL :: Const a b -> Int -> Const a b | |||||
FiniteBits a => FiniteBits (Const a b) | |||||
Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int countLeadingZeros :: Const a b -> Int countTrailingZeros :: Const a b -> Int | |||||
Bounded a => Bounded (Const a b) | |||||
Enum a => Enum (Const a b) | |||||
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> 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] # | |||||
Floating a => Floating (Const a b) | |||||
Defined in Data.Functor.Const Methods exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b | |||||
RealFloat a => RealFloat (Const a b) | |||||
Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # | |||||
Generic (Const a b) | |||||
Defined in Data.Functor.Const Associated Types
| |||||
Ix a => Ix (Const a b) | |||||
Defined in Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] index :: (Const a b, Const a b) -> Const a b -> Int unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int inRange :: (Const a b, Const a b) -> Const a b -> Bool rangeSize :: (Const a b, Const a b) -> Int unsafeRangeSize :: (Const a b, Const a b) -> Int | |||||
Num a => Num (Const a b) | |||||
Defined in Data.Functor.Const | |||||
Read a => Read (Const a b) | |||||
Fractional a => Fractional (Const a b) | |||||
Integral a => Integral (Const a b) | |||||
Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # | |||||
Real a => Real (Const a b) | |||||
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational # | |||||
RealFrac a => RealFrac (Const a b) | |||||
Show a => Show (Const a b) | |||||
NFData a => NFData (Const a b) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (Const a b) | |||||
Ord a => Ord (Const a b) | |||||
type Rep1 (Const a :: k -> Type) | |||||
Defined in Data.Functor.Const | |||||
type Rep (Const a b) | |||||
Defined in Data.Functor.Const |
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #
Methods
traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #
sequenceA :: Applicative f => t (f a) -> f (t a) #
Instances
Instances
Data Bool | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool dataTypeOf :: Bool -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool | |||||
Storable Bool | |||||
Defined in Foreign.Storable | |||||
Bits Bool | |||||
Defined in GHC.Bits Methods (.|.) :: Bool -> Bool -> Bool # complement :: Bool -> Bool clearBit :: Bool -> Int -> Bool complementBit :: Bool -> Int -> Bool testBit :: Bool -> Int -> Bool bitSizeMaybe :: Bool -> Maybe Int unsafeShiftL :: Bool -> Int -> Bool unsafeShiftR :: Bool -> Int -> Bool rotateL :: Bool -> Int -> Bool | |||||
FiniteBits Bool | |||||
Defined in GHC.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |||||
Bounded Bool | |||||
Enum Bool | |||||
Generic Bool | |||||
Defined in GHC.Generics Associated Types
| |||||
SingKind Bool | |||||
Defined in GHC.Generics Associated Types
| |||||
Ix Bool | |||||
Read Bool | |||||
Show Bool | |||||
NFData Bool | |||||
Defined in Control.DeepSeq | |||||
Eq Bool | |||||
Ord Bool | |||||
Random Bool | |||||
Uniform Bool | |||||
Defined in System.Random.Internal | |||||
UniformRange Bool | |||||
Defined in System.Random.Internal | |||||
SingI 'False | |||||
Defined in GHC.Generics | |||||
SingI 'True | |||||
Defined in GHC.Generics | |||||
Lift Bool | |||||
type DemoteRep Bool | |||||
Defined in GHC.Generics | |||||
type Rep Bool | |||||
Defined in GHC.Generics | |||||
data Sing (a :: Bool) | |||||
Instances
Data Char | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char dataTypeOf :: Char -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) gmapT :: (forall b. Data b => b -> b) -> Char -> Char gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char | |||||
Storable Char | |||||
Defined in Foreign.Storable | |||||
Bounded Char | |||||
Enum Char | |||||
Ix Char | |||||
Read Char | |||||
Show Char | |||||
IsChar Char | |||||
PrintfArg Char | |||||
Defined in Text.Printf | |||||
NFData Char | |||||
Defined in Control.DeepSeq | |||||
Eq Char | |||||
Ord Char | |||||
Random Char | |||||
Uniform Char | |||||
Defined in System.Random.Internal | |||||
UniformRange Char | |||||
Defined in System.Random.Internal | |||||
HasColorizer String Source # | |||||
Defined in XMonad.Actions.GridSelect | |||||
PPrint Char Source # | |||||
TestCoercion SChar | |||||
Defined in GHC.TypeLits Methods testCoercion :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (Coercion a b) | |||||
TestEquality SChar | |||||
Defined in GHC.TypeLits Methods testEquality :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (a :~: b) | |||||
Lift Char | |||||
Generic1 (URec Char :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
Foldable (UChar :: Type -> Type) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |||||
Traversable (UChar :: Type -> Type) | |||||
Defined in Data.Traversable | |||||
HasName [Char] Source # | |||||
Functor (URec Char :: Type -> Type) | |||||
HasName (X (), String) Source # | |||||
HasName (X (), [String]) Source # | |||||
HasName (NamedAction, String) Source # | |||||
Defined in XMonad.Util.NamedActions | |||||
Generic (URec Char p) | |||||
Defined in GHC.Generics Associated Types
| |||||
Show (URec Char p) | |||||
Eq (URec Char p) | |||||
Ord (URec Char p) | |||||
Defined in GHC.Generics | |||||
data URec Char (p :: k) | |||||
Defined in GHC.Generics | |||||
type Compare (a :: Char) (b :: Char) | |||||
Defined in Data.Type.Ord | |||||
type Rep1 (URec Char :: k -> Type) | |||||
Defined in GHC.Generics | |||||
type Rep (URec Char p) | |||||
Defined in GHC.Generics |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
class Semigroup a => Monoid a where #
Instances
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () #
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
isSuffixOf :: Eq a => [a] -> [a] -> Bool #
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
Instances
Data Any | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any dataTypeOf :: Any -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Any) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) gmapT :: (forall b. Data b => b -> b) -> Any -> Any gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any | |||||
Monoid Any | |||||
Semigroup Any | |||||
Bounded Any | |||||
Generic Any | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Read Any | |||||
Show Any | |||||
Default Any | |||||
Defined in Data.Default.Class | |||||
NFData Any | |||||
Defined in Control.DeepSeq | |||||
Eq Any | |||||
Ord Any | |||||
type Rep Any | |||||
(<**>) :: Applicative f => f a -> f (a -> b) -> f b #
liftA :: Applicative f => (a -> b) -> f a -> f b #
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d #
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #
intToDigit :: Int -> Char #
Constructors
Product | |
Fields
|
Instances
MonadFix Product | |||||
Defined in Control.Monad.Fix | |||||
MonadZip Product | |||||
Foldable Product | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |||||
Foldable1 Product | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Product m -> m foldMap1 :: Semigroup m => (a -> m) -> Product a -> m foldMap1' :: Semigroup m => (a -> m) -> Product a -> m toNonEmpty :: Product a -> NonEmpty a maximum :: Ord a => Product a -> a minimum :: Ord a => Product a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Product a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Product a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Product a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Product a -> b | |||||
Traversable Product | |||||
Applicative Product | |||||
Functor Product | |||||
Monad Product | |||||
NFData1 Product | |||||
Defined in Control.DeepSeq | |||||
Generic1 Product | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Data a => Data (Product a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) toConstr :: Product a -> Constr dataTypeOf :: Product a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) | |||||
Num a => Monoid (Product a) | |||||
Num a => Semigroup (Product a) | |||||
Bounded a => Bounded (Product a) | |||||
Generic (Product a) | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Num a => Num (Product a) | |||||
Defined in Data.Semigroup.Internal | |||||
Read a => Read (Product a) | |||||
Show a => Show (Product a) | |||||
Num a => Default (Product a) | |||||
Defined in Data.Default.Class | |||||
NFData a => NFData (Product a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (Product a) | |||||
Ord a => Ord (Product a) | |||||
type Rep1 Product | |||||
Defined in Data.Semigroup.Internal | |||||
type Rep (Product a) | |||||
Defined in Data.Semigroup.Internal |
Instances
MonadFix Sum | |||||
Defined in Control.Monad.Fix | |||||
MonadZip Sum | |||||
Foldable Sum | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |||||
Foldable1 Sum | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Sum m -> m foldMap1 :: Semigroup m => (a -> m) -> Sum a -> m foldMap1' :: Semigroup m => (a -> m) -> Sum a -> m toNonEmpty :: Sum a -> NonEmpty a maximum :: Ord a => Sum a -> a minimum :: Ord a => Sum a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Sum a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Sum a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Sum a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Sum a -> b | |||||
Traversable Sum | |||||
Applicative Sum | |||||
Functor Sum | |||||
Monad Sum | |||||
NFData1 Sum | |||||
Defined in Control.DeepSeq | |||||
Generic1 Sum | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Data a => Data (Sum a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) dataTypeOf :: Sum a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) | |||||
Num a => Monoid (Sum a) | |||||
Num a => Semigroup (Sum a) | |||||
Bounded a => Bounded (Sum a) | |||||
Generic (Sum a) | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Num a => Num (Sum a) | |||||
Read a => Read (Sum a) | |||||
Show a => Show (Sum a) | |||||
Num a => Default (Sum a) | |||||
Defined in Data.Default.Class | |||||
NFData a => NFData (Sum a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (Sum a) | |||||
Ord a => Ord (Sum a) | |||||
type Rep1 Sum | |||||
Defined in Data.Semigroup.Internal | |||||
type Rep (Sum a) | |||||
Defined in Data.Semigroup.Internal |
newtype Ap (f :: k -> Type) (a :: k) #
Instances
Generic1 (Ap f :: k -> Type) | |||||
Defined in Data.Monoid Associated Types
| |||||
MonadFail f => MonadFail (Ap f) | |||||
Defined in Data.Monoid | |||||
MonadFix f => MonadFix (Ap f) | |||||
Defined in Control.Monad.Fix | |||||
Foldable f => Foldable (Ap f) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m # foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m # foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b # foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b # foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |||||
Foldable1 f => Foldable1 (Ap f) | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Ap f m -> m foldMap1 :: Semigroup m => (a -> m) -> Ap f a -> m foldMap1' :: Semigroup m => (a -> m) -> Ap f a -> m toNonEmpty :: Ap f a -> NonEmpty a maximum :: Ord a => Ap f a -> a minimum :: Ord a => Ap f a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Ap f a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Ap f a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Ap f a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Ap f a -> b | |||||
Traversable f => Traversable (Ap f) | |||||
Alternative f => Alternative (Ap f) | |||||
Applicative f => Applicative (Ap f) | |||||
Functor f => Functor (Ap f) | |||||
Monad f => Monad (Ap f) | |||||
MonadPlus f => MonadPlus (Ap f) | |||||
(Data (f a), Data a, Typeable f) => Data (Ap f a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ap f a -> c (Ap f a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ap f a) dataTypeOf :: Ap f a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ap f a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ap f a)) gmapT :: (forall b. Data b => b -> b) -> Ap f a -> Ap f a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r gmapQ :: (forall d. Data d => d -> u) -> Ap f a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Ap f a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) | |||||
(Applicative f, Monoid a) => Monoid (Ap f a) | |||||
(Applicative f, Semigroup a) => Semigroup (Ap f a) | |||||
(Applicative f, Bounded a) => Bounded (Ap f a) | |||||
Enum (f a) => Enum (Ap f a) | |||||
Defined in Data.Monoid | |||||
Generic (Ap f a) | |||||
Defined in Data.Monoid Associated Types
| |||||
(Applicative f, Num a) => Num (Ap f a) | |||||
Read (f a) => Read (Ap f a) | |||||
Show (f a) => Show (Ap f a) | |||||
Eq (f a) => Eq (Ap f a) | |||||
Ord (f a) => Ord (Ap f a) | |||||
type Rep1 (Ap f :: k -> Type) | |||||
Defined in Data.Monoid | |||||
type Rep (Ap f a) | |||||
Defined in Data.Monoid |
showLitChar :: Char -> ShowS #
Instances
MonadFix First | |||||
Defined in Control.Monad.Fix | |||||
MonadZip First | |||||
Foldable First | |||||
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |||||
Traversable First | |||||
Applicative First | |||||
Functor First | |||||
Monad First | |||||
NFData1 First | |||||
Defined in Control.DeepSeq | |||||
Generic1 First | |||||
Defined in Data.Monoid Associated Types
| |||||
Data a => Data (First a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) dataTypeOf :: First a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) gmapT :: (forall b. Data b => b -> b) -> First a -> First a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) | |||||
Monoid (First a) | |||||
Semigroup (First a) | |||||
Generic (First a) | |||||
Defined in Data.Monoid Associated Types
| |||||
Read a => Read (First a) | |||||
Show a => Show (First a) | |||||
Default (First a) | |||||
Defined in Data.Default.Class | |||||
NFData a => NFData (First a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (First a) | |||||
Ord a => Ord (First a) | |||||
type Rep1 First | |||||
type Rep (First a) | |||||
Instances
MonadFix Last | |||||
Defined in Control.Monad.Fix | |||||
MonadZip Last | |||||
Foldable Last | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |||||
Traversable Last | |||||
Applicative Last | |||||
Functor Last | |||||
Monad Last | |||||
NFData1 Last | |||||
Defined in Control.DeepSeq | |||||
Generic1 Last | |||||
Defined in Data.Monoid Associated Types
| |||||
Data a => Data (Last a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) dataTypeOf :: Last a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) | |||||
Monoid (Last a) | |||||
Semigroup (Last a) | |||||
Generic (Last a) | |||||
Defined in Data.Monoid Associated Types
| |||||
Read a => Read (Last a) | |||||
Show a => Show (Last a) | |||||
Default (Last a) | |||||
Defined in Data.Default.Class | |||||
NFData a => NFData (Last a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (Last a) | |||||
Ord a => Ord (Last a) | |||||
type Rep1 Last | |||||
type Rep (Last a) | |||||
newtype Alt (f :: k -> Type) (a :: k) #
Instances
Generic1 (Alt f :: k -> Type) | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
MonadFix f => MonadFix (Alt f) | |||||
Defined in Control.Monad.Fix | |||||
MonadZip f => MonadZip (Alt f) | |||||
Foldable f => Foldable (Alt f) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m # foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m # foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b # foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b # foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # | |||||
Foldable1 f => Foldable1 (Alt f) | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Alt f m -> m foldMap1 :: Semigroup m => (a -> m) -> Alt f a -> m foldMap1' :: Semigroup m => (a -> m) -> Alt f a -> m toNonEmpty :: Alt f a -> NonEmpty a maximum :: Ord a => Alt f a -> a minimum :: Ord a => Alt f a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Alt f a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Alt f a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Alt f a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Alt f a -> b | |||||
Contravariant f => Contravariant (Alt f) | |||||
Traversable f => Traversable (Alt f) | |||||
Alternative f => Alternative (Alt f) | |||||
Applicative f => Applicative (Alt f) | |||||
Functor f => Functor (Alt f) | |||||
Monad f => Monad (Alt f) | |||||
MonadPlus f => MonadPlus (Alt f) | |||||
(Data (f a), Data a, Typeable f) => Data (Alt f a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt f a -> c (Alt f a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt f a) dataTypeOf :: Alt f a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt f a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt f a)) gmapT :: (forall b. Data b => b -> b) -> Alt f a -> Alt f a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r gmapQ :: (forall d. Data d => d -> u) -> Alt f a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt f a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) | |||||
Alternative f => Monoid (Alt f a) | |||||
Alternative f => Semigroup (Alt f a) | |||||
Enum (f a) => Enum (Alt f a) | |||||
Generic (Alt f a) | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Num (f a) => Num (Alt f a) | |||||
Read (f a) => Read (Alt f a) | |||||
Show (f a) => Show (Alt f a) | |||||
Eq (f a) => Eq (Alt f a) | |||||
Ord (f a) => Ord (Alt f a) | |||||
Defined in Data.Semigroup.Internal | |||||
type Rep1 (Alt f :: k -> Type) | |||||
Defined in Data.Semigroup.Internal | |||||
type Rep (Alt f a) | |||||
Defined in Data.Semigroup.Internal |
Instances
MonadFix Dual | |||||
Defined in Control.Monad.Fix | |||||
MonadZip Dual | |||||
Foldable Dual | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m # foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b # foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |||||
Foldable1 Dual | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => Dual m -> m foldMap1 :: Semigroup m => (a -> m) -> Dual a -> m foldMap1' :: Semigroup m => (a -> m) -> Dual a -> m toNonEmpty :: Dual a -> NonEmpty a maximum :: Ord a => Dual a -> a minimum :: Ord a => Dual a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> Dual a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> Dual a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> Dual a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> Dual a -> b | |||||
Traversable Dual | |||||
Applicative Dual | |||||
Functor Dual | |||||
Monad Dual | |||||
NFData1 Dual | |||||
Defined in Control.DeepSeq | |||||
Generic1 Dual | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Data a => Data (Dual a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) dataTypeOf :: Dual a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) | |||||
Monoid a => Monoid (Dual a) | |||||
Semigroup a => Semigroup (Dual a) | |||||
Bounded a => Bounded (Dual a) | |||||
Generic (Dual a) | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
Read a => Read (Dual a) | |||||
Show a => Show (Dual a) | |||||
Default a => Default (Dual a) | |||||
Defined in Data.Default.Class | |||||
NFData a => NFData (Dual a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (Dual a) | |||||
Ord a => Ord (Dual a) | |||||
type Rep1 Dual | |||||
Defined in Data.Semigroup.Internal | |||||
type Rep (Dual a) | |||||
Defined in Data.Semigroup.Internal |
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f () #
forever :: Applicative f => f a -> f b #
optional :: Alternative f => f a -> f (Maybe a) #
lexLitChar :: ReadS String #
readLitChar :: ReadS Char #
generalCategory :: Char -> GeneralCategory #
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #
dropWhileEnd :: (a -> Bool) -> [a] -> [a] #
elemIndices :: Eq a => a -> [a] -> [Int] #
findIndices :: (a -> Bool) -> [a] -> [Int] #
genericDrop :: Integral i => i -> [a] -> [a] #
genericIndex :: Integral i => [a] -> i -> a #
genericLength :: Num i => [a] -> i #
genericReplicate :: Integral i => i -> a -> [a] #
genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) #
genericTake :: Integral i => i -> [a] -> [a] #
intercalate :: [a] -> [[a]] -> [a] #
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #
intersperse :: a -> [a] -> [a] #
permutations :: [a] -> [[a]] #
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a] #
subsequences :: [a] -> [[a]] #
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] #
mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b) #
mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b) #
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool #
replicateM_ :: Applicative m => Int -> m a -> m () #
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 () #
newtype WrappedArrow (a :: Type -> Type -> Type) b c #
Constructors
WrapArrow | |
Fields
|
Instances
Generic1 (WrappedArrow a b :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 to1 :: Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 | |||||
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |||||
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # | |||||
Arrow a => Applicative (WrappedArrow a b) | |||||
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |||||
Arrow a => Functor (WrappedArrow a b) | |||||
Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |||||
(Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> WrappedArrow a b c -> c0 (WrappedArrow a b c) gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) toConstr :: WrappedArrow a b c -> Constr dataTypeOf :: WrappedArrow a b c -> DataType dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) | |||||
Generic (WrappedArrow a b c) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c | |||||
type Rep1 (WrappedArrow a b :: Type -> Type) | |||||
Defined in Control.Applicative type Rep1 (WrappedArrow a b :: Type -> Type) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (a b)))) | |||||
type Rep (WrappedArrow a b c) | |||||
Defined in Control.Applicative type Rep (WrappedArrow a b c) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a b c)))) |
newtype WrappedMonad (m :: Type -> Type) a #
Constructors
WrapMonad | |
Fields
|
Instances
Generic1 (WrappedMonad m :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a | |||||
MonadPlus m => Alternative (WrappedMonad m) | |||||
Defined in Control.Applicative Methods empty :: WrappedMonad m a # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] # | |||||
Monad m => Applicative (WrappedMonad m) | |||||
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |||||
Monad m => Functor (WrappedMonad m) | |||||
Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a # | |||||
Monad m => Monad (WrappedMonad m) | |||||
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # | |||||
(Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonad m a -> c (WrappedMonad m a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) toConstr :: WrappedMonad m a -> Constr dataTypeOf :: WrappedMonad m a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) | |||||
Generic (WrappedMonad m a) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x to :: Rep (WrappedMonad m a) x -> WrappedMonad m a | |||||
type Rep1 (WrappedMonad m :: Type -> Type) | |||||
Defined in Control.Applicative type Rep1 (WrappedMonad m :: Type -> Type) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 m))) | |||||
type Rep (WrappedMonad m a) | |||||
Defined in Control.Applicative type Rep (WrappedMonad m a) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m a)))) |
Constructors
ZipList | |
Fields
|
Instances
Foldable ZipList | |||||
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |||||
Traversable ZipList | |||||
Alternative ZipList | |||||
Applicative ZipList | |||||
Functor ZipList | |||||
NFData1 ZipList | |||||
Defined in Control.DeepSeq | |||||
Generic1 ZipList | |||||
Defined in Control.Applicative Associated Types
| |||||
Data a => Data (ZipList a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) toConstr :: ZipList a -> Constr dataTypeOf :: ZipList a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) | |||||
Generic (ZipList a) | |||||
Defined in Control.Applicative Associated Types
| |||||
IsList (ZipList a) | |||||
Read a => Read (ZipList a) | |||||
Show a => Show (ZipList a) | |||||
NFData a => NFData (ZipList a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (ZipList a) | |||||
Ord a => Ord (ZipList a) | |||||
type Rep1 ZipList | |||||
Defined in Control.Applicative | |||||
type Rep (ZipList a) | |||||
Defined in Control.Applicative | |||||
type Item (ZipList a) | |||||
Defined in GHC.IsList type Item (ZipList a) = a |
isAsciiLower :: Char -> Bool #
isAsciiUpper :: Char -> Bool #
isHexDigit :: Char -> Bool #
isLowerCase :: Char -> Bool #
isOctDigit :: Char -> Bool #
isPunctuation :: Char -> Bool #
isUpperCase :: Char -> Bool #
digitToInt :: Char -> Int #
isSeparator :: Char -> Bool #
fmapDefault :: Traversable t => (a -> b) -> t a -> t b #
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m #
forAccumM :: (Monad m, Traversable t) => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b) #
mapAccumM :: (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b) #
chunksOf :: Int -> [a] -> [[a]] Source #
Given a maximum length, splits a list into sublists
>>>
chunksOf 5 (take 30 $ repeat 'a')
["aaaaa","aaaaa","aaaaa","aaaaa","aaaaa","aaaaa"]
(.:) :: (a -> b) -> (c -> d -> a) -> c -> d -> b Source #
Multivariable composition.
f .: g ≡ (f .) . g ≡ \c d -> f (g c d)
Constructors
a :| [a] |
Instances
MonadFix NonEmpty | |||||
Defined in Control.Monad.Fix | |||||
MonadZip NonEmpty | |||||
Foldable NonEmpty | |||||
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |||||
Foldable1 NonEmpty | |||||
Defined in Data.Foldable1 Methods fold1 :: Semigroup m => NonEmpty m -> m foldMap1 :: Semigroup m => (a -> m) -> NonEmpty a -> m foldMap1' :: Semigroup m => (a -> m) -> NonEmpty a -> m toNonEmpty :: NonEmpty a -> NonEmpty a maximum :: Ord a => NonEmpty a -> a minimum :: Ord a => NonEmpty a -> a foldrMap1 :: (a -> b) -> (a -> b -> b) -> NonEmpty a -> b foldlMap1' :: (a -> b) -> (b -> a -> b) -> NonEmpty a -> b foldlMap1 :: (a -> b) -> (b -> a -> b) -> NonEmpty a -> b foldrMap1' :: (a -> b) -> (a -> b -> b) -> NonEmpty a -> b | |||||
Eq1 NonEmpty | |||||
Ord1 NonEmpty | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> NonEmpty a -> NonEmpty b -> Ordering | |||||
Read1 NonEmpty | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a] | |||||
Show1 NonEmpty | |||||
Defined in Data.Functor.Classes | |||||
Traversable NonEmpty | |||||
Applicative NonEmpty | |||||
Functor NonEmpty | |||||
Monad NonEmpty | |||||
NFData1 NonEmpty | |||||
Defined in Control.DeepSeq | |||||
Generic1 NonEmpty | |||||
Defined in GHC.Generics Associated Types
| |||||
Lift a => Lift (NonEmpty a :: Type) | |||||
Data a => Data (NonEmpty a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) toConstr :: NonEmpty a -> Constr dataTypeOf :: NonEmpty a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) | |||||
Semigroup (NonEmpty a) | |||||
Generic (NonEmpty a) | |||||
Defined in GHC.Generics Associated Types
| |||||
IsList (NonEmpty a) | |||||
Read a => Read (NonEmpty a) | |||||
Show a => Show (NonEmpty a) | |||||
NFData a => NFData (NonEmpty a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (NonEmpty a) | |||||
Ord a => Ord (NonEmpty a) | |||||
type Rep1 NonEmpty | |||||
Defined in GHC.Generics type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 []))) | |||||
type Rep (NonEmpty a) | |||||
Defined in GHC.Generics type Rep (NonEmpty a) = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a]))) | |||||
type Item (NonEmpty a) | |||||
Defined in GHC.IsList type Item (NonEmpty a) = a |
notEmpty :: HasCallStack => [a] -> NonEmpty a Source #
fromList
with a better error message. Useful to
silence GHC's Pattern match(es) are non-exhaustive warning in places where
the programmer knows it's always non-empty, but it's infeasible to express
that in the type system.
safeGetWindowAttributes :: Window -> X (Maybe WindowAttributes) Source #
A safe version of getWindowAttributes
.
mkAbsolutePath :: MonadIO m => FilePath -> m FilePath Source #
(Naïvely) turn a relative path into an absolute one.
- If the path starts with
/
, do nothing. - If it starts with
~/
, replace that with the actual home - directory.
- If it starts with
$
, read the name of an environment - variable and replace it with the contents of that.
- Otherwise, prepend the home directory and
/
to the path.
findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a) Source #
Like find
, but takes a monadic function instead; retains the
short-circuiting behaviour of the non-monadic version.
For example,
findM (\a -> putStr (show a <> " ") >> pure False) [1..10]
would print "1 2 3 4 5 6 7 8 9 10" and return Nothing
, while
findM (\a -> putStr (show a <> " ") >> pure True) [1..10]
would print "1"
and return Just 1
.
Keys
Convert a modifier mask into a useful string.
cleanKeyMask :: X (KeyMask -> KeyMask) Source #
Strip numlock, capslock, mouse buttons and XKB group from a KeyMask
,
leaving only modifier keys like Shift, Control, Super, Hyper in the mask
(hence the "Key" in "cleanKeyMask").
Core's cleanMask
only strips the first two because key events from
passive grabs (key bindings) are stripped of mouse buttons and XKB group by
the X server already for compatibility reasons. For more info, see:
https://www.x.org/releases/X11R7.7/doc/kbproto/xkbproto.html#Delivering_a_Key_or_Button_Event_to_a_Client
regularKeys :: [(String, KeySym)] Source #
A list of "regular" (extended ASCII) keys.
allSpecialKeys :: [(String, KeySym)] Source #
A list of all special key names and their associated KeySyms.
specialKeys :: [(String, KeySym)] Source #
A list of special key names and their corresponding KeySyms.
multimediaKeys :: [(String, KeySym)] Source #
List of multimedia keys. If Xlib does not know about some keysym
it's omitted from the list (stringToKeysym
returns noSymbol
in
this case).
functionKeys :: [(String, KeySym)] Source #
A list pairing function key descriptor strings (e.g. "<F2>"
)
with the associated KeySyms.
type WindowScreen = Screen WorkspaceId (Layout Window) Window ScreenId ScreenDetail Source #
Infinite streams
An infinite stream type