| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
Text.XML.HaXml.Schema.Schema
Synopsis
- class SchemaType a where
- parseSchemaType :: String -> XMLParser a
- schemaTypeToXML :: String -> a -> [Content ()]
- class SimpleType a where
- acceptingParser :: TextParser a
- simpleTypeText :: a -> String
- class Extension t s where
- supertype :: t -> s
- class Restricts t s | t -> s where
- restricts :: t -> s
- class FwdDecl fd a | fd -> a
- getAttribute :: (SimpleType a, Show a) => String -> Element Posn -> Posn -> XMLParser a
- between :: PolyParse p => Occurs -> p a -> p [a]
- data Occurs = Occurs (Maybe Int) (Maybe Int)
- parseSimpleType :: SimpleType t => XMLParser t
- parseText :: XMLParser String
- data AnyElement
- = (SchemaType a, Show a) => ANYSchemaType a
- | UnconvertedANY (Content Posn)
- parseAnyElement :: XMLParser AnyElement
- data Content i
- type XMLParser a = Parser (Content Posn) a
- posnElement :: [String] -> XMLParser (Posn, Element Posn)
- posnElementWith :: (String -> String -> Bool) -> [String] -> XMLParser (Posn, Element Posn)
- element :: [String] -> XMLParser (Element Posn)
- interior :: Element Posn -> XMLParser a -> XMLParser a
- text :: XMLParser String
- class Functor f => Applicative (f :: Type -> Type) where
- class Applicative f => Alternative (f :: Type -> Type) where
- (<$) :: Functor f => a -> f b -> f a
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- liftA :: Applicative f => (a -> b) -> f a -> f b
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- satisfy :: (t -> Bool) -> Parser t t
- eof :: Parser t ()
- optional :: Alternative f => f a -> f (Maybe a)
- many1 :: PolyParse p => p a -> p [a]
- sepBy :: PolyParse p => p a -> p sep -> p [a]
- sepBy1 :: PolyParse p => p a -> p sep -> p [a]
- apply :: PolyParse p => p (a -> b) -> p a -> p b
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- newtype Const a (b :: k) = Const {
- getConst :: a
- bracket :: PolyParse p => p bra -> p ket -> p a -> p a
- newtype ZipList a = ZipList {
- getZipList :: [a]
- newtype WrappedArrow (a :: Type -> Type -> Type) b c = WrapArrow {
- unwrapArrow :: a b c
- newtype WrappedMonad (m :: Type -> Type) a = WrapMonad {
- unwrapMonad :: m a
- newtype Parser t a = P ([t] -> Result [t] a)
- data Result z a
- reparse :: [t] -> Parser t ()
- class (Functor p, Monad p, MonadFail p, Applicative p, Alternative p, Commitment p) => PolyParse (p :: Type -> Type)
- class Commitment (p :: Type -> Type) where
- discard :: PolyParse p => p a -> p b -> p a
- failBad :: PolyParse p => String -> p a
- adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a
- oneOf :: PolyParse p => [p a] -> p a
- indent :: Int -> String -> String
- exactly :: PolyParse p => Int -> p a -> p [a]
- upto :: PolyParse p => Int -> p a -> p [a]
- bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a]
- manyFinally :: PolyParse p => p a -> p z -> p [a]
- manyFinally' :: (PolyParse p, Show a) => p a -> p z -> p [a]
- onFail :: Parser t a -> Parser t a -> Parser t a
- next :: Parser t t
- satisfyMsg :: Show t => (t -> Bool) -> String -> Parser t t
- runParser :: Parser t a -> [t] -> (Either String a, [t])
- class Functor f => Applicative (f :: Type -> Type) where
- class Applicative f => Alternative (f :: Type -> Type) where
- (<$) :: Functor f => a -> f b -> f a
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- liftA :: Applicative f => (a -> b) -> f a -> f b
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- satisfy :: (t -> Bool) -> Parser t t
- eof :: Parser t ()
- optional :: Alternative f => f a -> f (Maybe a)
- many1 :: PolyParse p => p a -> p [a]
- sepBy :: PolyParse p => p a -> p sep -> p [a]
- sepBy1 :: PolyParse p => p a -> p sep -> p [a]
- parens :: Bool -> TextParser a -> TextParser a
- apply :: PolyParse p => p (a -> b) -> p a -> p b
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- newtype Const a (b :: k) = Const {
- getConst :: a
- bracket :: PolyParse p => p bra -> p ket -> p a -> p a
- newtype ZipList a = ZipList {
- getZipList :: [a]
- newtype WrappedArrow (a :: Type -> Type -> Type) b c = WrapArrow {
- unwrapArrow :: a b c
- newtype WrappedMonad (m :: Type -> Type) a = WrapMonad {
- unwrapMonad :: m a
- newtype Parser t a = P ([t] -> Result [t] a)
- data Result z a
- reparse :: [t] -> Parser t ()
- class (Functor p, Monad p, MonadFail p, Applicative p, Alternative p, Commitment p) => PolyParse (p :: Type -> Type)
- class Commitment (p :: Type -> Type) where
- discard :: PolyParse p => p a -> p b -> p a
- failBad :: PolyParse p => String -> p a
- adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a
- oneOf :: PolyParse p => [p a] -> p a
- indent :: Int -> String -> String
- exactly :: PolyParse p => Int -> p a -> p [a]
- upto :: PolyParse p => Int -> p a -> p [a]
- bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a]
- manyFinally :: PolyParse p => p a -> p z -> p [a]
- manyFinally' :: (PolyParse p, Show a) => p a -> p z -> p [a]
- onFail :: Parser t a -> Parser t a -> Parser t a
- next :: Parser t t
- satisfyMsg :: Show t => (t -> Bool) -> String -> Parser t t
- runParser :: Parser t a -> [t] -> (Either String a, [t])
- class Parse a where
- parse :: TextParser a
- parsePrec :: Int -> TextParser a
- parseList :: TextParser [a]
- type TextParser a = Parser Char a
- parseByRead :: Read a => String -> TextParser a
- readByParse :: TextParser a -> ReadS a
- readsPrecByParsePrec :: (Int -> TextParser a) -> Int -> ReadS a
- word :: TextParser String
- isWord :: String -> TextParser String
- literal :: String -> TextParser String
- optionalParens :: TextParser a -> TextParser a
- field :: Parse a => String -> TextParser a
- constructors :: [(String, TextParser a)] -> TextParser a
- enumeration :: Show a => String -> [a] -> TextParser a
- parseSigned :: Real a => TextParser a -> TextParser a
- parseInt :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> TextParser a
- parseDec :: Integral a => TextParser a
- parseOct :: Integral a => TextParser a
- parseHex :: Integral a => TextParser a
- parseFloat :: RealFrac a => TextParser a
- parseLitChar' :: TextParser Char
- parseLitChar :: TextParser Char
- allAsString :: TextParser String
- module Text.XML.HaXml.OneOfN
- toXMLElement :: String -> [[Attribute]] -> [[Content ()]] -> [Content ()]
- toXMLText :: String -> [Content ()]
- toXMLAnyElement :: AnyElement -> [Content ()]
- toXMLAttribute :: SimpleType a => String -> a -> [Attribute]
- addXMLAttributes :: [[Attribute]] -> [Content ()] -> [Content ()]
Documentation
class SchemaType a where Source #
A SchemaType promises to interconvert between a generic XML content tree and a Haskell value, according to the rules of XSD.
Methods
parseSchemaType :: String -> XMLParser a Source #
schemaTypeToXML :: String -> a -> [Content ()] Source #
Instances
class SimpleType a where Source #
Ultimately, an XML parser will find some plain text as the content of a simpleType, which will need to be parsed. We use a TextParser, because values of simpleTypes can also be given elsewhere, e.g. as attribute values in an XSD definition, e.g. to restrict the permissible values of the simpleType. Such restrictions are therefore implemented as layered parsers.
Instances
class Extension t s where Source #
A type t can extend another type s by the addition of extra elements and/or attributes. s is therefore the supertype of t.
class Restricts t s | t -> s where Source #
A type t can restrict another type s, that is, t admits fewer values than s, but all the values t does admit also belong to the type s.
class FwdDecl fd a | fd -> a Source #
A trick to enable forward-declaration of a type that will be defined
properly in another module, higher in the dependency graph. fd is
a dummy type e.g. the empty data FwdA, where a is the proper
data A, not yet available.
getAttribute :: (SimpleType a, Show a) => String -> Element Posn -> Posn -> XMLParser a Source #
Generated parsers will use getAttribute as a convenient wrapper
to lift a SchemaAttribute parser into an XMLParser.
between :: PolyParse p => Occurs -> p a -> p [a] Source #
Between is a list parser that tries to ensure that any range specification (min and max elements) is obeyed when parsing.
parseSimpleType :: SimpleType t => XMLParser t Source #
Given a TextParser for a SimpleType, make it into an XMLParser, i.e. consuming textual XML content as input rather than a String.
data AnyElement Source #
The xsd:any type. Parsing will always produce an UnconvertedANY.
Constructors
| (SchemaType a, Show a) => ANYSchemaType a | |
| UnconvertedANY (Content Posn) |
Instances
| SchemaType AnyElement Source # | |
Defined in Text.XML.HaXml.Schema.Schema Methods parseSchemaType :: String -> XMLParser AnyElement Source # schemaTypeToXML :: String -> AnyElement -> [Content ()] Source # | |
| Show AnyElement Source # | |
Defined in Text.XML.HaXml.Schema.Schema | |
| Eq AnyElement Source # | |
Defined in Text.XML.HaXml.Schema.Schema Methods (==) :: AnyElement -> AnyElement -> Bool Source # (/=) :: AnyElement -> AnyElement -> Bool Source # | |
Constructors
| CElem (Element i) i | |
| CString Bool CharData i | bool is whether whitespace is significant |
| CRef Reference i | |
| CMisc Misc i |
type XMLParser a = Parser (Content Posn) a Source #
We need a parsing monad for reading generic XML Content into specific datatypes. This is a specialisation of the Text.ParserCombinators.Poly ones, where the input token type is fixed as XML Content.
posnElement :: [String] -> XMLParser (Posn, Element Posn) Source #
A specialisation of posnElementWith (==).
posnElementWith :: (String -> String -> Bool) -> [String] -> XMLParser (Posn, Element Posn) Source #
Get the next content element, checking that it has one of the required tags, using the given matching function. (Skips over comments and whitespace, rejects text and refs. Also returns position of element.)
element :: [String] -> XMLParser (Element Posn) Source #
Get the next content element, checking that it has one of the required tags. (Skips over comments and whitespace, rejects text and refs.)
interior :: Element Posn -> XMLParser a -> XMLParser a Source #
Run an XMLParser on the contents of the given element (i.e. not on the current monadic content sequence), checking that the contents are exhausted, before returning the calculated value within the current parser context.
class Functor f => Applicative (f :: Type -> Type) where Source #
A functor with application, providing operations to
A minimal complete definition must include implementations of pure
and of either <*> or liftA2. If it defines both, then they must behave
the same as their default definitions:
(<*>) =liftA2id
liftA2f x y = f<$>x<*>y
Further, any definition must satisfy the following:
- Identity
pureid<*>v = v- Composition
pure(.)<*>u<*>v<*>w = u<*>(v<*>w)- Homomorphism
puref<*>purex =pure(f x)- Interchange
u
<*>purey =pure($y)<*>u
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor instance for f will satisfy
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2p (liftA2q u v) =liftA2f u .liftA2g v
If f is also a Monad, it should satisfy
(which implies that pure and <*> satisfy the applicative functor laws).
Methods
Lift a value into the Structure.
Examples
>>>pure 1 :: Maybe IntJust 1
>>>pure 'z' :: [Char]"z"
>>>pure (pure ":D") :: Maybe [String]Just [":D"]
(<*>) :: f (a -> b) -> f a -> f b infixl 4 Source #
Sequential application.
A few functors support an implementation of <*> that is more
efficient than the default one.
Example
Used in combination with (<$>)(<*>)
>>>data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
>>>produceFoo :: Applicative f => f Foo>>>produceBar :: Applicative f => f Bar>>>produceBaz :: Applicative f => f Baz
>>>mkState :: Applicative f => f MyState>>>mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
liftA2 :: (a -> b -> c) -> f a -> f b -> f c Source #
Lift a binary function to actions.
Some functors support an implementation of liftA2 that is more
efficient than the default one. In particular, if fmap is an
expensive operation, it is likely better to use liftA2 than to
fmap over the structure and then use <*>.
This became a typeclass method in 4.10.0.0. Prior to that, it was
a function defined in terms of <*> and fmap.
Example
>>>liftA2 (,) (Just 3) (Just 5)Just (3,5)
>>>liftA2 (+) [1, 2, 3] [4, 5, 6][5,6,7,6,7,8,7,8,9]
(*>) :: f a -> f b -> f b infixl 4 Source #
Sequence actions, discarding the value of the first argument.
Examples
If used in conjunction with the Applicative instance for Maybe,
you can chain Maybe computations, with a possible "early return"
in case of Nothing.
>>>Just 2 *> Just 3Just 3
>>>Nothing *> Just 3Nothing
Of course a more interesting use case would be to have effectful computations instead of just returning pure values.
>>>import Data.Char>>>import GHC.Internal.Text.ParserCombinators.ReadP>>>let p = string "my name is " *> munch1 isAlpha <* eof>>>readP_to_S p "my name is Simon"[("Simon","")]
(<*) :: f a -> f b -> f a infixl 4 Source #
Sequence actions, discarding the value of the second argument.
Instances
| Applicative Complex | Since: base-4.9.0.0 |
| Applicative First | Since: base-4.9.0.0 |
| Applicative Last | Since: base-4.9.0.0 |
| Applicative Max | Since: base-4.9.0.0 |
| Applicative Min | Since: base-4.9.0.0 |
| Applicative Put | |
| Applicative Seq | Since: containers-0.5.4 |
| Applicative Tree | |
| Applicative NonEmpty | Since: base-4.9.0.0 |
Defined in GHC.Internal.Base | |
| Applicative ZipList | f <$> ZipList xs1 <*> ... <*> ZipList xsN
= ZipList (zipWithN f xs1 ... xsN)where (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
= ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
= ZipList {getZipList = ["a5","b6b6","c7c7c7"]}Since: base-2.1 |
Defined in GHC.Internal.Functor.ZipList | |
| Applicative Par1 | Since: base-4.9.0.0 |
| Applicative P | Since: base-4.5.0.0 |
| Applicative ReadP | Since: base-4.6.0.0 |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| Applicative IO | Since: base-2.1 |
| Applicative Parser | |
Defined in Text.ParserCombinators.HuttonMeijer | |
| Applicative Parser | |
Defined in Text.ParserCombinators.Poly.ByteString | |
| Applicative Parser | |
Defined in Text.ParserCombinators.Poly.ByteStringChar | |
| Applicative Parser | |
Defined in Text.ParserCombinators.Poly.Text | |
| Applicative Maybe | Since: base-2.1 |
| Applicative Solo | Since: base-4.15 |
| Applicative [] | Since: base-2.1 |
| Monad m => Applicative (WrappedMonad m) | Since: base-2.1 |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a Source # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source # | |
| Applicative (SetM s) | |
| Applicative (Either e) | Since: base-3.0 |
Defined in GHC.Internal.Data.Either | |
| Applicative (U1 :: Type -> Type) | Since: base-4.9.0.0 |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lazy | |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lex | |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
| Applicative (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText | |
| Monoid a => Applicative ((,) a) | For tuples, the ("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)Since: base-2.1 |
| Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1 |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 Source # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a Source # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c Source # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b Source # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a Source # | |
| Monoid m => Applicative (Const m :: Type -> Type) | Since: base-2.0.1 |
Defined in GHC.Internal.Data.Functor.Const | |
| (Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | Since: base-4.17.0.0 |
Defined in GHC.Internal.Generics Methods pure :: a -> Generically1 f a Source # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b Source # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c Source # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b Source # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a Source # | |
| Applicative f => Applicative (Rec1 f) | Since: base-4.9.0.0 |
| Applicative (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateLazy Methods pure :: a -> Parser s t a Source # (<*>) :: Parser s t (a -> b) -> Parser s t a -> Parser s t b Source # liftA2 :: (a -> b -> c) -> Parser s t a -> Parser s t b -> Parser s t c Source # (*>) :: Parser s t a -> Parser s t b -> Parser s t b Source # (<*) :: Parser s t a -> Parser s t b -> Parser s t a Source # | |
| Applicative (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateParser Methods pure :: a -> Parser s t a Source # (<*>) :: Parser s t (a -> b) -> Parser s t a -> Parser s t b Source # liftA2 :: (a -> b -> c) -> Parser s t a -> Parser s t b -> Parser s t c Source # (*>) :: Parser s t a -> Parser s t b -> Parser s t b Source # (<*) :: Parser s t a -> Parser s t b -> Parser s t a Source # | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | Since: base-4.14.0.0 |
Defined in GHC.Internal.Base | |
| (Applicative f, Applicative g) => Applicative (Product f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Product Methods pure :: a -> Product f g a Source # (<*>) :: Product f g (a -> b) -> Product f g a -> Product f g b Source # liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c Source # (*>) :: Product f g a -> Product f g b -> Product f g b Source # (<*) :: Product f g a -> Product f g b -> Product f g a Source # | |
| (Monad f, Applicative f) => Applicative (WhenMatched f x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a Source # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c Source # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b Source # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a Source # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f k x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a Source # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c Source # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b Source # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a Source # | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | Since: base-4.9.0.0 |
Defined in GHC.Internal.Generics | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | Since: base-4.12.0.0 |
| Applicative (Parser s t e) | |
Defined in Text.ParserCombinators.HuttonMeijerWallace Methods pure :: a -> Parser s t e a Source # (<*>) :: Parser s t e (a -> b) -> Parser s t e a -> Parser s t e b Source # liftA2 :: (a -> b -> c) -> Parser s t e a -> Parser s t e b -> Parser s t e c Source # (*>) :: Parser s t e a -> Parser s t e b -> Parser s t e b Source # (<*) :: Parser s t e a -> Parser s t e b -> Parser s t e a Source # | |
| (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | Since: base-4.14.0.0 |
Defined in GHC.Internal.Base Methods pure :: a0 -> (a, b, c, a0) Source # (<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) Source # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) Source # (*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) Source # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) Source # | |
| Applicative ((->) r) | Since: base-2.1 |
| (Applicative f, Applicative g) => Applicative (Compose f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a Source # (<*>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b Source # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c Source # (*>) :: Compose f g a -> Compose f g b -> Compose f g b Source # (<*) :: Compose f g a -> Compose f g b -> Compose f g a Source # | |
| (Monad f, Applicative f) => Applicative (WhenMatched f k x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a Source # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c Source # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b Source # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a Source # | |
| (Applicative f, Applicative g) => Applicative (f :.: g) | Since: base-4.9.0.0 |
Defined in GHC.Internal.Generics | |
| Applicative f => Applicative (M1 i c f) | Since: base-4.9.0.0 |
Defined in GHC.Internal.Generics | |
class Applicative f => Alternative (f :: Type -> Type) where Source #
A monoid on applicative functors.
If defined, some and many should be the least solutions
of the equations:
Examples
>>>Nothing <|> Just 42Just 42
>>>[1, 2] <|> [3, 4][1,2,3,4]
>>>empty <|> print (2^15)32768
Methods
The identity of <|>
empty <|> a == a a <|> empty == a
(<|>) :: f a -> f a -> f a infixl 3 Source #
An associative binary operation
One or more.
Examples
>>>some (putStr "la")lalalalalalalalala... * goes on forever *
>>>some Nothingnothing
>>>take 5 <$> some (Just 1)* hangs forever *
Note that this function can be used with Parsers based on
Applicatives. In that case some parser will attempt to
parse parser one or more times until it fails.
Zero or more.
Examples
>>>many (putStr "la")lalalalalalalalala... * goes on forever *
>>>many NothingJust []
>>>take 5 <$> many (Just 1)* hangs forever *
Note that this function can be used with Parsers based on
Applicatives. In that case many parser will attempt to
parse parser zero or more times until it fails.
Instances
| Alternative Seq | Since: containers-0.5.4 |
| Alternative ZipList | Since: base-4.11.0.0 |
| Alternative P | Since: base-4.5.0.0 |
| Alternative ReadP | Since: base-4.6.0.0 |
| Alternative IO | Takes the first non-throwing Since: base-4.9.0.0 |
| Alternative Parser | |
| Alternative Parser | |
| Alternative Parser | |
| Alternative Parser | |
| Alternative Maybe | Picks the leftmost Since: base-2.1 |
| Alternative [] | Combines lists by concatenation, starting from the empty list. Since: base-2.1 |
| MonadPlus m => Alternative (WrappedMonad m) | Since: base-2.1 |
Defined in Control.Applicative Methods empty :: WrappedMonad m a Source # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source # some :: WrappedMonad m a -> WrappedMonad m [a] Source # many :: WrappedMonad m a -> WrappedMonad m [a] Source # | |
| Alternative (U1 :: Type -> Type) | Since: base-4.9.0.0 |
| Alternative (Parser t) | |
| Alternative (Parser t) | |
| Alternative (Parser t) | |
| Alternative (Parser s) | |
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: base-2.1 |
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 Source # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 Source # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # | |
| (Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f) | Since: base-4.17.0.0 |
Defined in GHC.Internal.Generics Methods empty :: Generically1 f a Source # (<|>) :: Generically1 f a -> Generically1 f a -> Generically1 f a Source # some :: Generically1 f a -> Generically1 f [a] Source # many :: Generically1 f a -> Generically1 f [a] Source # | |
| Alternative f => Alternative (Rec1 f) | Since: base-4.9.0.0 |
| Alternative (Parser s t) | |
| Alternative (Parser s t) | |
| (Alternative f, Alternative g) => Alternative (Product f g) | Since: base-4.9.0.0 |
| (Alternative f, Alternative g) => Alternative (f :*: g) | Since: base-4.9.0.0 |
| Alternative (Parser s t e) | |
| (Alternative f, Applicative g) => Alternative (Compose f g) | Since: base-4.9.0.0 |
| (Alternative f, Applicative g) => Alternative (f :.: g) | Since: base-4.9.0.0 |
| Alternative f => Alternative (M1 i c f) | Since: base-4.9.0.0 |
(<**>) :: Applicative f => f a -> f (a -> b) -> f b infixl 4 Source #
A variant of <*> with the types of the arguments reversed. It differs from
flip (<*>)
Examples
>>>(<**>) (print 1) (id <$ print 2)1 2
>>>flip (<*>) (print 1) (id <$ print 2)2 1
>>>ZipList [4, 5, 6] <**> ZipList [(+1), (*2), (/3)]ZipList {getZipList = [5.0,10.0,2.0]}
liftA :: Applicative f => (a -> b) -> f a -> f b Source #
Lift a function to actions.
Equivalent to Functor's fmap but implemented using only Applicative's methods:
liftA f a = pure f <*> a
As such this function may be used to implement a Functor instance from an Applicative one.
Examples
Using the Applicative instance for Lists:
>>>liftA (+1) [1, 2][2,3]
Or the Applicative instance for Maybe
>>>liftA (+1) (Just 3)Just 4
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d Source #
Lift a ternary function to actions.
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Source #
An infix synonym for fmap.
The name of this operator is an allusion to $.
Note the similarities between their types:
($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f b
Whereas $ is function application, <$> is function
application lifted over a Functor.
Examples
Convert from a Maybe IntMaybe
Stringshow:
>>>show <$> NothingNothing
>>>show <$> Just 3Just "3"
Convert from an Either Int IntEither IntString using show:
>>>show <$> Left 17Left 17
>>>show <$> Right 17Right "17"
Double each element of a list:
>>>(*2) <$> [1,2,3][2,4,6]
Apply even to the second element of a pair:
>>>even <$> (2,2)(2,True)
optional :: Alternative f => f a -> f (Maybe a) Source #
One or none.
It is useful for modelling any computation that is allowed to fail.
Examples
Using the Alternative instance of Control.Monad.Except, the following functions:
>>>import Control.Monad.Except
>>>canFail = throwError "it failed" :: Except String Int>>>final = return 42 :: Except String Int
Can be combined by allowing the first function to fail:
>>>runExcept $ canFail *> finalLeft "it failed"
>>>runExcept $ optional canFail *> finalRight 42
asum :: (Foldable t, Alternative f) => t (f a) -> f a Source #
The sum of a collection of actions using (<|>), generalizing concat.
asum is just like msum, but generalised to Alternative.
Examples
Basic usage:
>>>asum [Just "Hello", Nothing, Just "World"]Just "Hello"
newtype Const a (b :: k) Source #
The Const functor.
Examples
>>>fmap (++ "World") (Const "Hello")Const "Hello"
Because we ignore the second type parameter to Const,
the Applicative instance, which has
(<*>) :: Monoid m => Const m (a -> b) -> Const m a -> Const m bMonoid m => m -> m -> m, which is (<>)
>>>Const [1, 2, 3] <*> Const [4, 5, 6]Const [1,2,3,4,5,6]
Instances
Lists, but with an Applicative functor based on zipping.
Examples
In contrast to the Applicative for List:
>>>(+) <$> [1, 2, 3] <*> [4, 5, 6][5,6,7,6,7,8,7,8,9]
The Applicative instance of ZipList applies the operation
by pairing up the elements, analogous to zipWithN
>>>(+) <$> ZipList [1, 2, 3] <*> ZipList [4, 5, 6]ZipList {getZipList = [5,7,9]}
>>>(,,,) <$> ZipList [1, 2] <*> ZipList [3, 4] <*> ZipList [5, 6] <*> ZipList [7, 8]ZipList {getZipList = [(1,3,5,7),(2,4,6,8)]}
>>>ZipList [(+1), (^2), (/ 2)] <*> ZipList [5, 5, 5]ZipList {getZipList = [6.0,25.0,2.5]}
Constructors
| ZipList | |
Fields
| |
Instances
| Alternative ZipList | Since: base-4.11.0.0 | ||||
| Applicative ZipList | f <$> ZipList xs1 <*> ... <*> ZipList xsN
= ZipList (zipWithN f xs1 ... xsN)where (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
= ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
= ZipList {getZipList = ["a5","b6b6","c7c7c7"]}Since: base-2.1 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| Functor ZipList | Since: base-2.1 | ||||
| Foldable ZipList | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList Methods fold :: Monoid m => ZipList m -> m Source # foldMap :: Monoid m => (a -> m) -> ZipList a -> m Source # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m Source # foldr :: (a -> b -> b) -> b -> ZipList a -> b Source # foldr' :: (a -> b -> b) -> b -> ZipList a -> b Source # foldl :: (b -> a -> b) -> b -> ZipList a -> b Source # foldl' :: (b -> a -> b) -> b -> ZipList a -> b Source # foldr1 :: (a -> a -> a) -> ZipList a -> a Source # foldl1 :: (a -> a -> a) -> ZipList a -> a Source # toList :: ZipList a -> [a] Source # null :: ZipList a -> Bool Source # length :: ZipList a -> Int Source # elem :: Eq a => a -> ZipList a -> Bool Source # maximum :: Ord a => ZipList a -> a Source # minimum :: Ord a => ZipList a -> a Source # | |||||
| Traversable ZipList | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| Generic1 ZipList | |||||
Defined in GHC.Internal.Functor.ZipList Associated Types
| |||||
| Data a => Data (ZipList a) | Since: base-4.14.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) Source # toConstr :: ZipList a -> Constr Source # dataTypeOf :: ZipList a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) Source # gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # | |||||
| Generic (ZipList a) | |||||
Defined in GHC.Internal.Functor.ZipList Associated Types
| |||||
| IsList (ZipList a) | Since: base-4.15.0.0 | ||||
| Read a => Read (ZipList a) | Since: base-4.7.0.0 | ||||
| Show a => Show (ZipList a) | Since: base-4.7.0.0 | ||||
| Eq a => Eq (ZipList a) | Since: base-4.7.0.0 | ||||
| Ord a => Ord (ZipList a) | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Rep1 ZipList | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Rep (ZipList a) | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Item (ZipList a) | |||||
Defined in GHC.Internal.IsList | |||||
newtype WrappedArrow (a :: Type -> Type -> Type) b c Source #
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 Source # to1 :: Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 Source # | |||||
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 Source # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 Source # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # | |||||
| Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 Source # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source # | |||||
| Arrow a => Functor (WrappedArrow a b) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source # | |||||
| (Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c) | Since: base-4.14.0.0 | ||||
Defined in Control.Applicative 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) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) Source # toConstr :: WrappedArrow a b c -> Constr Source # dataTypeOf :: WrappedArrow a b c -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # | |||||
| Generic (WrappedArrow a b c) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x Source # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c Source # | |||||
| type Rep1 (WrappedArrow a b :: Type -> Type) | Since: base-4.7.0.0 | ||||
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) | Since: base-4.7.0.0 | ||||
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 Source #
Constructors
| WrapMonad | |
Fields
| |
Instances
| Generic1 (WrappedMonad m :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a Source # to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a Source # | |||||
| MonadPlus m => Alternative (WrappedMonad m) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods empty :: WrappedMonad m a Source # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source # some :: WrappedMonad m a -> WrappedMonad m [a] Source # many :: WrappedMonad m a -> WrappedMonad m [a] Source # | |||||
| Monad m => Applicative (WrappedMonad m) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a Source # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source # | |||||
| Monad m => Functor (WrappedMonad m) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a Source # | |||||
| Monad m => Monad (WrappedMonad m) | Since: base-4.7.0.0 | ||||
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b Source # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # return :: a -> WrappedMonad m a Source # | |||||
| (Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a) | Since: base-4.14.0.0 | ||||
Defined in Control.Applicative 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) Source # toConstr :: WrappedMonad m a -> Constr Source # dataTypeOf :: WrappedMonad m a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) Source # gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u Source # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # | |||||
| Generic (WrappedMonad m a) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source # | |||||
| type Rep1 (WrappedMonad m :: Type -> Type) | Since: base-4.7.0.0 | ||||
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) | Since: base-4.7.0.0 | ||||
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)))) | |||||
Instances
| Alternative (Parser t) | |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
| Functor (Parser t) | |
| Monad (Parser t) | |
| MonadFail (Parser t) | |
| Commitment (Parser t) | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
class (Functor p, Monad p, MonadFail p, Applicative p, Alternative p, Commitment p) => PolyParse (p :: Type -> Type) #
Instances
| PolyParse Parser | |
Defined in Text.ParserCombinators.Poly.ByteString | |
| PolyParse Parser | |
Defined in Text.ParserCombinators.Poly.ByteStringChar | |
| PolyParse Parser | |
Defined in Text.ParserCombinators.Poly.Text | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lazy | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lex | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
| PolyParse (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText | |
| PolyParse (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateLazy | |
| PolyParse (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateParser | |
class Commitment (p :: Type -> Type) where #
Instances
| Commitment Parser | |
| Commitment Parser | |
| Commitment Parser | |
| Commitment (Parser t) | |
| Commitment (Parser t) | |
| Commitment (Parser t) | |
| Commitment (Parser s) | |
| Commitment (Parser s t) | |
| Commitment (Parser s t) | |
adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a #
bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] #
manyFinally :: PolyParse p => p a -> p z -> p [a] #
manyFinally' :: (PolyParse p, Show a) => p a -> p z -> p [a] #
class Functor f => Applicative (f :: Type -> Type) where Source #
A functor with application, providing operations to
A minimal complete definition must include implementations of pure
and of either <*> or liftA2. If it defines both, then they must behave
the same as their default definitions:
(<*>) =liftA2id
liftA2f x y = f<$>x<*>y
Further, any definition must satisfy the following:
- Identity
pureid<*>v = v- Composition
pure(.)<*>u<*>v<*>w = u<*>(v<*>w)- Homomorphism
puref<*>purex =pure(f x)- Interchange
u
<*>purey =pure($y)<*>u
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor instance for f will satisfy
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2p (liftA2q u v) =liftA2f u .liftA2g v
If f is also a Monad, it should satisfy
(which implies that pure and <*> satisfy the applicative functor laws).
Methods
Lift a value into the Structure.
Examples
>>>pure 1 :: Maybe IntJust 1
>>>pure 'z' :: [Char]"z"
>>>pure (pure ":D") :: Maybe [String]Just [":D"]
(<*>) :: f (a -> b) -> f a -> f b infixl 4 Source #
Sequential application.
A few functors support an implementation of <*> that is more
efficient than the default one.
Example
Used in combination with (<$>)(<*>)
>>>data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
>>>produceFoo :: Applicative f => f Foo>>>produceBar :: Applicative f => f Bar>>>produceBaz :: Applicative f => f Baz
>>>mkState :: Applicative f => f MyState>>>mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
liftA2 :: (a -> b -> c) -> f a -> f b -> f c Source #
Lift a binary function to actions.
Some functors support an implementation of liftA2 that is more
efficient than the default one. In particular, if fmap is an
expensive operation, it is likely better to use liftA2 than to
fmap over the structure and then use <*>.
This became a typeclass method in 4.10.0.0. Prior to that, it was
a function defined in terms of <*> and fmap.
Example
>>>liftA2 (,) (Just 3) (Just 5)Just (3,5)
>>>liftA2 (+) [1, 2, 3] [4, 5, 6][5,6,7,6,7,8,7,8,9]
(*>) :: f a -> f b -> f b infixl 4 Source #
Sequence actions, discarding the value of the first argument.
Examples
If used in conjunction with the Applicative instance for Maybe,
you can chain Maybe computations, with a possible "early return"
in case of Nothing.
>>>Just 2 *> Just 3Just 3
>>>Nothing *> Just 3Nothing
Of course a more interesting use case would be to have effectful computations instead of just returning pure values.
>>>import Data.Char>>>import GHC.Internal.Text.ParserCombinators.ReadP>>>let p = string "my name is " *> munch1 isAlpha <* eof>>>readP_to_S p "my name is Simon"[("Simon","")]
(<*) :: f a -> f b -> f a infixl 4 Source #
Sequence actions, discarding the value of the second argument.
Instances
| Applicative Complex | Since: base-4.9.0.0 |
| Applicative First | Since: base-4.9.0.0 |
| Applicative Last | Since: base-4.9.0.0 |
| Applicative Max | Since: base-4.9.0.0 |
| Applicative Min | Since: base-4.9.0.0 |
| Applicative Put | |
| Applicative Seq | Since: containers-0.5.4 |
| Applicative Tree | |
| Applicative NonEmpty | Since: base-4.9.0.0 |
Defined in GHC.Internal.Base | |
| Applicative ZipList | f <$> ZipList xs1 <*> ... <*> ZipList xsN
= ZipList (zipWithN f xs1 ... xsN)where (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
= ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
= ZipList {getZipList = ["a5","b6b6","c7c7c7"]}Since: base-2.1 |
Defined in GHC.Internal.Functor.ZipList | |
| Applicative Par1 | Since: base-4.9.0.0 |
| Applicative P | Since: base-4.5.0.0 |
| Applicative ReadP | Since: base-4.6.0.0 |
Defined in GHC.Internal.Text.ParserCombinators.ReadP | |
| Applicative IO | Since: base-2.1 |
| Applicative Parser | |
Defined in Text.ParserCombinators.HuttonMeijer | |
| Applicative Parser | |
Defined in Text.ParserCombinators.Poly.ByteString | |
| Applicative Parser | |
Defined in Text.ParserCombinators.Poly.ByteStringChar | |
| Applicative Parser | |
Defined in Text.ParserCombinators.Poly.Text | |
| Applicative Maybe | Since: base-2.1 |
| Applicative Solo | Since: base-4.15 |
| Applicative [] | Since: base-2.1 |
| Monad m => Applicative (WrappedMonad m) | Since: base-2.1 |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a Source # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source # | |
| Applicative (SetM s) | |
| Applicative (Either e) | Since: base-3.0 |
Defined in GHC.Internal.Data.Either | |
| Applicative (U1 :: Type -> Type) | Since: base-4.9.0.0 |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lazy | |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lex | |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
| Applicative (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText | |
| Monoid a => Applicative ((,) a) | For tuples, the ("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)Since: base-2.1 |
| Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1 |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 Source # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a Source # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c Source # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b Source # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a Source # | |
| Monoid m => Applicative (Const m :: Type -> Type) | Since: base-2.0.1 |
Defined in GHC.Internal.Data.Functor.Const | |
| (Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | Since: base-4.17.0.0 |
Defined in GHC.Internal.Generics Methods pure :: a -> Generically1 f a Source # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b Source # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c Source # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b Source # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a Source # | |
| Applicative f => Applicative (Rec1 f) | Since: base-4.9.0.0 |
| Applicative (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateLazy Methods pure :: a -> Parser s t a Source # (<*>) :: Parser s t (a -> b) -> Parser s t a -> Parser s t b Source # liftA2 :: (a -> b -> c) -> Parser s t a -> Parser s t b -> Parser s t c Source # (*>) :: Parser s t a -> Parser s t b -> Parser s t b Source # (<*) :: Parser s t a -> Parser s t b -> Parser s t a Source # | |
| Applicative (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateParser Methods pure :: a -> Parser s t a Source # (<*>) :: Parser s t (a -> b) -> Parser s t a -> Parser s t b Source # liftA2 :: (a -> b -> c) -> Parser s t a -> Parser s t b -> Parser s t c Source # (*>) :: Parser s t a -> Parser s t b -> Parser s t b Source # (<*) :: Parser s t a -> Parser s t b -> Parser s t a Source # | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | Since: base-4.14.0.0 |
Defined in GHC.Internal.Base | |
| (Applicative f, Applicative g) => Applicative (Product f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Product Methods pure :: a -> Product f g a Source # (<*>) :: Product f g (a -> b) -> Product f g a -> Product f g b Source # liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c Source # (*>) :: Product f g a -> Product f g b -> Product f g b Source # (<*) :: Product f g a -> Product f g b -> Product f g a Source # | |
| (Monad f, Applicative f) => Applicative (WhenMatched f x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a Source # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c Source # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b Source # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a Source # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f k x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a Source # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c Source # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b Source # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a Source # | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | Since: base-4.9.0.0 |
Defined in GHC.Internal.Generics | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | Since: base-4.12.0.0 |
| Applicative (Parser s t e) | |
Defined in Text.ParserCombinators.HuttonMeijerWallace Methods pure :: a -> Parser s t e a Source # (<*>) :: Parser s t e (a -> b) -> Parser s t e a -> Parser s t e b Source # liftA2 :: (a -> b -> c) -> Parser s t e a -> Parser s t e b -> Parser s t e c Source # (*>) :: Parser s t e a -> Parser s t e b -> Parser s t e b Source # (<*) :: Parser s t e a -> Parser s t e b -> Parser s t e a Source # | |
| (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | Since: base-4.14.0.0 |
Defined in GHC.Internal.Base Methods pure :: a0 -> (a, b, c, a0) Source # (<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) Source # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) Source # (*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) Source # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) Source # | |
| Applicative ((->) r) | Since: base-2.1 |
| (Applicative f, Applicative g) => Applicative (Compose f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a Source # (<*>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b Source # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c Source # (*>) :: Compose f g a -> Compose f g b -> Compose f g b Source # (<*) :: Compose f g a -> Compose f g b -> Compose f g a Source # | |
| (Monad f, Applicative f) => Applicative (WhenMatched f k x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a Source # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c Source # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b Source # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a Source # | |
| (Applicative f, Applicative g) => Applicative (f :.: g) | Since: base-4.9.0.0 |
Defined in GHC.Internal.Generics | |
| Applicative f => Applicative (M1 i c f) | Since: base-4.9.0.0 |
Defined in GHC.Internal.Generics | |
class Applicative f => Alternative (f :: Type -> Type) where Source #
A monoid on applicative functors.
If defined, some and many should be the least solutions
of the equations:
Examples
>>>Nothing <|> Just 42Just 42
>>>[1, 2] <|> [3, 4][1,2,3,4]
>>>empty <|> print (2^15)32768
Methods
The identity of <|>
empty <|> a == a a <|> empty == a
(<|>) :: f a -> f a -> f a infixl 3 Source #
An associative binary operation
One or more.
Examples
>>>some (putStr "la")lalalalalalalalala... * goes on forever *
>>>some Nothingnothing
>>>take 5 <$> some (Just 1)* hangs forever *
Note that this function can be used with Parsers based on
Applicatives. In that case some parser will attempt to
parse parser one or more times until it fails.
Zero or more.
Examples
>>>many (putStr "la")lalalalalalalalala... * goes on forever *
>>>many NothingJust []
>>>take 5 <$> many (Just 1)* hangs forever *
Note that this function can be used with Parsers based on
Applicatives. In that case many parser will attempt to
parse parser zero or more times until it fails.
Instances
| Alternative Seq | Since: containers-0.5.4 |
| Alternative ZipList | Since: base-4.11.0.0 |
| Alternative P | Since: base-4.5.0.0 |
| Alternative ReadP | Since: base-4.6.0.0 |
| Alternative IO | Takes the first non-throwing Since: base-4.9.0.0 |
| Alternative Parser | |
| Alternative Parser | |
| Alternative Parser | |
| Alternative Parser | |
| Alternative Maybe | Picks the leftmost Since: base-2.1 |
| Alternative [] | Combines lists by concatenation, starting from the empty list. Since: base-2.1 |
| MonadPlus m => Alternative (WrappedMonad m) | Since: base-2.1 |
Defined in Control.Applicative Methods empty :: WrappedMonad m a Source # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source # some :: WrappedMonad m a -> WrappedMonad m [a] Source # many :: WrappedMonad m a -> WrappedMonad m [a] Source # | |
| Alternative (U1 :: Type -> Type) | Since: base-4.9.0.0 |
| Alternative (Parser t) | |
| Alternative (Parser t) | |
| Alternative (Parser t) | |
| Alternative (Parser s) | |
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: base-2.1 |
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 Source # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 Source # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # | |
| (Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f) | Since: base-4.17.0.0 |
Defined in GHC.Internal.Generics Methods empty :: Generically1 f a Source # (<|>) :: Generically1 f a -> Generically1 f a -> Generically1 f a Source # some :: Generically1 f a -> Generically1 f [a] Source # many :: Generically1 f a -> Generically1 f [a] Source # | |
| Alternative f => Alternative (Rec1 f) | Since: base-4.9.0.0 |
| Alternative (Parser s t) | |
| Alternative (Parser s t) | |
| (Alternative f, Alternative g) => Alternative (Product f g) | Since: base-4.9.0.0 |
| (Alternative f, Alternative g) => Alternative (f :*: g) | Since: base-4.9.0.0 |
| Alternative (Parser s t e) | |
| (Alternative f, Applicative g) => Alternative (Compose f g) | Since: base-4.9.0.0 |
| (Alternative f, Applicative g) => Alternative (f :.: g) | Since: base-4.9.0.0 |
| Alternative f => Alternative (M1 i c f) | Since: base-4.9.0.0 |
(<**>) :: Applicative f => f a -> f (a -> b) -> f b infixl 4 Source #
A variant of <*> with the types of the arguments reversed. It differs from
flip (<*>)
Examples
>>>(<**>) (print 1) (id <$ print 2)1 2
>>>flip (<*>) (print 1) (id <$ print 2)2 1
>>>ZipList [4, 5, 6] <**> ZipList [(+1), (*2), (/3)]ZipList {getZipList = [5.0,10.0,2.0]}
liftA :: Applicative f => (a -> b) -> f a -> f b Source #
Lift a function to actions.
Equivalent to Functor's fmap but implemented using only Applicative's methods:
liftA f a = pure f <*> a
As such this function may be used to implement a Functor instance from an Applicative one.
Examples
Using the Applicative instance for Lists:
>>>liftA (+1) [1, 2][2,3]
Or the Applicative instance for Maybe
>>>liftA (+1) (Just 3)Just 4
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d Source #
Lift a ternary function to actions.
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Source #
An infix synonym for fmap.
The name of this operator is an allusion to $.
Note the similarities between their types:
($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f b
Whereas $ is function application, <$> is function
application lifted over a Functor.
Examples
Convert from a Maybe IntMaybe
Stringshow:
>>>show <$> NothingNothing
>>>show <$> Just 3Just "3"
Convert from an Either Int IntEither IntString using show:
>>>show <$> Left 17Left 17
>>>show <$> Right 17Right "17"
Double each element of a list:
>>>(*2) <$> [1,2,3][2,4,6]
Apply even to the second element of a pair:
>>>even <$> (2,2)(2,True)
optional :: Alternative f => f a -> f (Maybe a) Source #
One or none.
It is useful for modelling any computation that is allowed to fail.
Examples
Using the Alternative instance of Control.Monad.Except, the following functions:
>>>import Control.Monad.Except
>>>canFail = throwError "it failed" :: Except String Int>>>final = return 42 :: Except String Int
Can be combined by allowing the first function to fail:
>>>runExcept $ canFail *> finalLeft "it failed"
>>>runExcept $ optional canFail *> finalRight 42
parens :: Bool -> TextParser a -> TextParser a #
asum :: (Foldable t, Alternative f) => t (f a) -> f a Source #
The sum of a collection of actions using (<|>), generalizing concat.
asum is just like msum, but generalised to Alternative.
Examples
Basic usage:
>>>asum [Just "Hello", Nothing, Just "World"]Just "Hello"
newtype Const a (b :: k) Source #
The Const functor.
Examples
>>>fmap (++ "World") (Const "Hello")Const "Hello"
Because we ignore the second type parameter to Const,
the Applicative instance, which has
(<*>) :: Monoid m => Const m (a -> b) -> Const m a -> Const m bMonoid m => m -> m -> m, which is (<>)
>>>Const [1, 2, 3] <*> Const [4, 5, 6]Const [1,2,3,4,5,6]
Instances
| Generic1 (Const a :: k -> Type) | |||||
Defined in GHC.Internal.Data.Functor.Const Associated Types
| |||||
| Bifoldable (Const :: Type -> Type -> Type) | Since: base-4.10.0.0 | ||||
| Bifoldable1 (Const :: Type -> Type -> Type) | |||||
| Bifunctor (Const :: Type -> Type -> Type) | Since: base-4.8.0.0 | ||||
| Bitraversable (Const :: Type -> Type -> Type) | Since: base-4.10.0.0 | ||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) Source # | |||||
| Eq2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 | ||||
| Ord2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes | |||||
| Read2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) Source # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] Source # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) Source # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] Source # | |||||
| Show2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes | |||||
| Eq a => Eq1 (Const a :: Type -> Type) | Since: base-4.9.0.0 | ||||
| Ord a => Ord1 (Const a :: Type -> Type) | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes | |||||
| Read a => Read1 (Const a :: Type -> Type) | Since: base-4.9.0.0 | ||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) Source # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] Source # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) Source # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] Source # | |||||
| Show a => Show1 (Const a :: Type -> Type) | Since: base-4.9.0.0 | ||||
| Contravariant (Const a :: Type -> Type) | |||||
| Monoid m => Applicative (Const m :: Type -> Type) | Since: base-2.0.1 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Functor (Const m :: Type -> Type) | Since: base-2.1 | ||||
| Foldable (Const m :: Type -> Type) | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 Source # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldr :: (a -> b -> b) -> b -> Const m a -> b Source # foldr' :: (a -> b -> b) -> b -> Const m a -> b Source # foldl :: (b -> a -> b) -> b -> Const m a -> b Source # foldl' :: (b -> a -> b) -> b -> Const m a -> b Source # foldr1 :: (a -> a -> a) -> Const m a -> a Source # foldl1 :: (a -> a -> a) -> Const m a -> a Source # toList :: Const m a -> [a] Source # null :: Const m a -> Bool Source # length :: Const m a -> Int Source # elem :: Eq a => a -> Const m a -> Bool Source # maximum :: Ord a => Const m a -> a Source # minimum :: Ord a => Const m a -> a Source # | |||||
| Monoid a => Monoid (Const a b) | Since: base-4.9.0.0 | ||||
| Semigroup a => Semigroup (Const a b) | Since: base-4.9.0.0 | ||||
| Bits a => Bits (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b Source # (.|.) :: Const a b -> Const a b -> Const a b Source # xor :: Const a b -> Const a b -> Const a b Source # complement :: Const a b -> Const a b Source # shift :: Const a b -> Int -> Const a b Source # rotate :: Const a b -> Int -> Const a b Source # zeroBits :: Const a b Source # bit :: Int -> Const a b Source # setBit :: Const a b -> Int -> Const a b Source # clearBit :: Const a b -> Int -> Const a b Source # complementBit :: Const a b -> Int -> Const a b Source # testBit :: Const a b -> Int -> Bool Source # bitSizeMaybe :: Const a b -> Maybe Int Source # bitSize :: Const a b -> Int Source # isSigned :: Const a b -> Bool Source # shiftL :: Const a b -> Int -> Const a b Source # unsafeShiftL :: Const a b -> Int -> Const a b Source # shiftR :: Const a b -> Int -> Const a b Source # unsafeShiftR :: Const a b -> Int -> Const a b Source # rotateL :: Const a b -> Int -> Const a b Source # | |||||
| FiniteBits a => FiniteBits (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods finiteBitSize :: Const a b -> Int Source # countLeadingZeros :: Const a b -> Int Source # countTrailingZeros :: Const a b -> Int Source # | |||||
| Bounded a => Bounded (Const a b) | Since: base-4.9.0.0 | ||||
| Enum a => Enum (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods succ :: Const a b -> Const a b Source # pred :: Const a b -> Const a b Source # toEnum :: Int -> Const a b Source # fromEnum :: Const a b -> Int Source # enumFrom :: Const a b -> [Const a b] Source # enumFromThen :: Const a b -> Const a b -> [Const a b] Source # enumFromTo :: Const a b -> Const a b -> [Const a b] Source # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] Source # | |||||
| Floating a => Floating (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods exp :: Const a b -> Const a b Source # log :: Const a b -> Const a b Source # sqrt :: Const a b -> Const a b Source # (**) :: Const a b -> Const a b -> Const a b Source # logBase :: Const a b -> Const a b -> Const a b Source # sin :: Const a b -> Const a b Source # cos :: Const a b -> Const a b Source # tan :: Const a b -> Const a b Source # asin :: Const a b -> Const a b Source # acos :: Const a b -> Const a b Source # atan :: Const a b -> Const a b Source # sinh :: Const a b -> Const a b Source # cosh :: Const a b -> Const a b Source # tanh :: Const a b -> Const a b Source # asinh :: Const a b -> Const a b Source # acosh :: Const a b -> Const a b Source # atanh :: Const a b -> Const a b Source # log1p :: Const a b -> Const a b Source # expm1 :: Const a b -> Const a b Source # | |||||
| RealFloat a => RealFloat (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods floatRadix :: Const a b -> Integer Source # floatDigits :: Const a b -> Int Source # floatRange :: Const a b -> (Int, Int) Source # decodeFloat :: Const a b -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Const a b Source # exponent :: Const a b -> Int Source # significand :: Const a b -> Const a b Source # scaleFloat :: Int -> Const a b -> Const a b Source # isNaN :: Const a b -> Bool Source # isInfinite :: Const a b -> Bool Source # isDenormalized :: Const a b -> Bool Source # isNegativeZero :: Const a b -> Bool Source # | |||||
| Storable a => Storable (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods sizeOf :: Const a b -> Int Source # alignment :: Const a b -> Int Source # peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) Source # pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () Source # peekByteOff :: Ptr b0 -> Int -> IO (Const a b) Source # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () Source # | |||||
| Generic (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Associated Types
| |||||
| Ix a => Ix (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] Source # index :: (Const a b, Const a b) -> Const a b -> Int Source # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int Source # inRange :: (Const a b, Const a b) -> Const a b -> Bool Source # | |||||
| Num a => Num (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b Source # (-) :: Const a b -> Const a b -> Const a b Source # (*) :: Const a b -> Const a b -> Const a b Source # negate :: Const a b -> Const a b Source # abs :: Const a b -> Const a b Source # signum :: Const a b -> Const a b Source # fromInteger :: Integer -> Const a b Source # | |||||
| Read a => Read (Const a b) | This instance would be equivalent to the derived instances of the
Since: base-4.8.0.0 | ||||
| Fractional a => Fractional (Const a b) | Since: base-4.9.0.0 | ||||
| Integral a => Integral (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b Source # rem :: Const a b -> Const a b -> Const a b Source # div :: Const a b -> Const a b -> Const a b Source # mod :: Const a b -> Const a b -> Const a b Source # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) Source # divMod :: Const a b -> Const a b -> (Const a b, Const a b) Source # | |||||
| Real a => Real (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods toRational :: Const a b -> Rational Source # | |||||
| RealFrac a => RealFrac (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Show a => Show (Const a b) | This instance would be equivalent to the derived instances of the
Since: base-4.8.0.0 | ||||
| Eq a => Eq (Const a b) | Since: base-4.9.0.0 | ||||
| Ord a => Ord (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| type Rep1 (Const a :: k -> Type) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| type Rep (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
Lists, but with an Applicative functor based on zipping.
Examples
In contrast to the Applicative for List:
>>>(+) <$> [1, 2, 3] <*> [4, 5, 6][5,6,7,6,7,8,7,8,9]
The Applicative instance of ZipList applies the operation
by pairing up the elements, analogous to zipWithN
>>>(+) <$> ZipList [1, 2, 3] <*> ZipList [4, 5, 6]ZipList {getZipList = [5,7,9]}
>>>(,,,) <$> ZipList [1, 2] <*> ZipList [3, 4] <*> ZipList [5, 6] <*> ZipList [7, 8]ZipList {getZipList = [(1,3,5,7),(2,4,6,8)]}
>>>ZipList [(+1), (^2), (/ 2)] <*> ZipList [5, 5, 5]ZipList {getZipList = [6.0,25.0,2.5]}
Constructors
| ZipList | |
Fields
| |
Instances
| Alternative ZipList | Since: base-4.11.0.0 | ||||
| Applicative ZipList | f <$> ZipList xs1 <*> ... <*> ZipList xsN
= ZipList (zipWithN f xs1 ... xsN)where (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
= ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
= ZipList {getZipList = ["a5","b6b6","c7c7c7"]}Since: base-2.1 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| Functor ZipList | Since: base-2.1 | ||||
| Foldable ZipList | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList Methods fold :: Monoid m => ZipList m -> m Source # foldMap :: Monoid m => (a -> m) -> ZipList a -> m Source # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m Source # foldr :: (a -> b -> b) -> b -> ZipList a -> b Source # foldr' :: (a -> b -> b) -> b -> ZipList a -> b Source # foldl :: (b -> a -> b) -> b -> ZipList a -> b Source # foldl' :: (b -> a -> b) -> b -> ZipList a -> b Source # foldr1 :: (a -> a -> a) -> ZipList a -> a Source # foldl1 :: (a -> a -> a) -> ZipList a -> a Source # toList :: ZipList a -> [a] Source # null :: ZipList a -> Bool Source # length :: ZipList a -> Int Source # elem :: Eq a => a -> ZipList a -> Bool Source # maximum :: Ord a => ZipList a -> a Source # minimum :: Ord a => ZipList a -> a Source # | |||||
| Traversable ZipList | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| Generic1 ZipList | |||||
Defined in GHC.Internal.Functor.ZipList Associated Types
| |||||
| Data a => Data (ZipList a) | Since: base-4.14.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) Source # toConstr :: ZipList a -> Constr Source # dataTypeOf :: ZipList a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) Source # gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # | |||||
| Generic (ZipList a) | |||||
Defined in GHC.Internal.Functor.ZipList Associated Types
| |||||
| IsList (ZipList a) | Since: base-4.15.0.0 | ||||
| Read a => Read (ZipList a) | Since: base-4.7.0.0 | ||||
| Show a => Show (ZipList a) | Since: base-4.7.0.0 | ||||
| Eq a => Eq (ZipList a) | Since: base-4.7.0.0 | ||||
| Ord a => Ord (ZipList a) | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Rep1 ZipList | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Rep (ZipList a) | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Functor.ZipList | |||||
| type Item (ZipList a) | |||||
Defined in GHC.Internal.IsList | |||||
newtype WrappedArrow (a :: Type -> Type -> Type) b c Source #
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 Source # to1 :: Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 Source # | |||||
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 Source # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 Source # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # | |||||
| Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 Source # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source # | |||||
| Arrow a => Functor (WrappedArrow a b) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source # | |||||
| (Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c) | Since: base-4.14.0.0 | ||||
Defined in Control.Applicative 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) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) Source # toConstr :: WrappedArrow a b c -> Constr Source # dataTypeOf :: WrappedArrow a b c -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # | |||||
| Generic (WrappedArrow a b c) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x Source # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c Source # | |||||
| type Rep1 (WrappedArrow a b :: Type -> Type) | Since: base-4.7.0.0 | ||||
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) | Since: base-4.7.0.0 | ||||
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 Source #
Constructors
| WrapMonad | |
Fields
| |
Instances
| Generic1 (WrappedMonad m :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a Source # to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a Source # | |||||
| MonadPlus m => Alternative (WrappedMonad m) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods empty :: WrappedMonad m a Source # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source # some :: WrappedMonad m a -> WrappedMonad m [a] Source # many :: WrappedMonad m a -> WrappedMonad m [a] Source # | |||||
| Monad m => Applicative (WrappedMonad m) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a Source # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source # | |||||
| Monad m => Functor (WrappedMonad m) | Since: base-2.1 | ||||
Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a Source # | |||||
| Monad m => Monad (WrappedMonad m) | Since: base-4.7.0.0 | ||||
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b Source # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # return :: a -> WrappedMonad m a Source # | |||||
| (Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a) | Since: base-4.14.0.0 | ||||
Defined in Control.Applicative 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) Source # toConstr :: WrappedMonad m a -> Constr Source # dataTypeOf :: WrappedMonad m a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) Source # gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u Source # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # | |||||
| Generic (WrappedMonad m a) | |||||
Defined in Control.Applicative Associated Types
Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source # | |||||
| type Rep1 (WrappedMonad m :: Type -> Type) | Since: base-4.7.0.0 | ||||
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) | Since: base-4.7.0.0 | ||||
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)))) | |||||
Instances
| Alternative (Parser t) | |
| Applicative (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
| Functor (Parser t) | |
| Monad (Parser t) | |
| MonadFail (Parser t) | |
| Commitment (Parser t) | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
class (Functor p, Monad p, MonadFail p, Applicative p, Alternative p, Commitment p) => PolyParse (p :: Type -> Type) #
Instances
| PolyParse Parser | |
Defined in Text.ParserCombinators.Poly.ByteString | |
| PolyParse Parser | |
Defined in Text.ParserCombinators.Poly.ByteStringChar | |
| PolyParse Parser | |
Defined in Text.ParserCombinators.Poly.Text | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lazy | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Lex | |
| PolyParse (Parser t) | |
Defined in Text.ParserCombinators.Poly.Parser | |
| PolyParse (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText | |
| PolyParse (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateLazy | |
| PolyParse (Parser s t) | |
Defined in Text.ParserCombinators.Poly.StateParser | |
class Commitment (p :: Type -> Type) where #
Instances
| Commitment Parser | |
| Commitment Parser | |
| Commitment Parser | |
| Commitment (Parser t) | |
| Commitment (Parser t) | |
| Commitment (Parser t) | |
| Commitment (Parser s) | |
| Commitment (Parser s t) | |
| Commitment (Parser s t) | |
adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a #
bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] #
manyFinally :: PolyParse p => p a -> p z -> p [a] #
manyFinally' :: (PolyParse p, Show a) => p a -> p z -> p [a] #
Minimal complete definition
Nothing
Instances
| Parse Ordering | |
Defined in Text.Parse Methods parse :: TextParser Ordering # parsePrec :: Int -> TextParser Ordering # parseList :: TextParser [Ordering] # | |
| Parse Integer | |
Defined in Text.Parse Methods parse :: TextParser Integer # parsePrec :: Int -> TextParser Integer # parseList :: TextParser [Integer] # | |
| Parse () | |
Defined in Text.Parse | |
| Parse Bool | |
Defined in Text.Parse Methods parse :: TextParser Bool # parsePrec :: Int -> TextParser Bool # parseList :: TextParser [Bool] # | |
| Parse Char | |
Defined in Text.Parse Methods parse :: TextParser Char # parsePrec :: Int -> TextParser Char # parseList :: TextParser [Char] # | |
| Parse Double | |
Defined in Text.Parse Methods parse :: TextParser Double # parsePrec :: Int -> TextParser Double # parseList :: TextParser [Double] # | |
| Parse Float | |
Defined in Text.Parse Methods parse :: TextParser Float # parsePrec :: Int -> TextParser Float # parseList :: TextParser [Float] # | |
| Parse Int | |
Defined in Text.Parse | |
| Parse a => Parse (Maybe a) | |
Defined in Text.Parse Methods parse :: TextParser (Maybe a) # parsePrec :: Int -> TextParser (Maybe a) # parseList :: TextParser [Maybe a] # | |
| Parse a => Parse [a] | |
Defined in Text.Parse | |
| (Parse a, Parse b) => Parse (Either a b) | |
Defined in Text.Parse Methods parse :: TextParser (Either a b) # parsePrec :: Int -> TextParser (Either a b) # parseList :: TextParser [Either a b] # | |
| (Parse a, Parse b) => Parse (a, b) | |
Defined in Text.Parse Methods parse :: TextParser (a, b) # parsePrec :: Int -> TextParser (a, b) # parseList :: TextParser [(a, b)] # | |
| (Parse a, Parse b, Parse c) => Parse (a, b, c) | |
Defined in Text.Parse Methods parse :: TextParser (a, b, c) # parsePrec :: Int -> TextParser (a, b, c) # parseList :: TextParser [(a, b, c)] # | |
type TextParser a = Parser Char a #
parseByRead :: Read a => String -> TextParser a #
readByParse :: TextParser a -> ReadS a #
readsPrecByParsePrec :: (Int -> TextParser a) -> Int -> ReadS a #
word :: TextParser String #
isWord :: String -> TextParser String #
literal :: String -> TextParser String #
optionalParens :: TextParser a -> TextParser a #
field :: Parse a => String -> TextParser a #
constructors :: [(String, TextParser a)] -> TextParser a #
enumeration :: Show a => String -> [a] -> TextParser a #
parseSigned :: Real a => TextParser a -> TextParser a #
parseDec :: Integral a => TextParser a #
parseOct :: Integral a => TextParser a #
parseHex :: Integral a => TextParser a #
parseFloat :: RealFrac a => TextParser a #
module Text.XML.HaXml.OneOfN
toXMLAnyElement :: AnyElement -> [Content ()] Source #
toXMLAttribute :: SimpleType a => String -> a -> [Attribute] Source #