-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Pure Haskell YAML 1.2 parser
--   
--   <tt>HsYAML</tt> is a <a>YAML 1.2</a> parser implementation for
--   Haskell.
--   
--   Features of <tt>HsYAML</tt> include:
--   
--   <ul>
--   <li>Pure Haskell implementation with small dependency footprint and
--   emphasis on strict compliance with the <a>YAML 1.2
--   specification</a>.</li>
--   <li>Direct decoding to native Haskell types via
--   (<tt>aeson</tt>-inspired) typeclass-based API (see
--   <a>Data.YAML</a>).</li>
--   <li>Support for constructing custom YAML node graph representation
--   (including support for cyclic YAML data structures).</li>
--   <li>Support for the standard (untyped) <i>Failsafe</i>, (strict)
--   <i>JSON</i>, and (flexible) <i>Core</i> "schemas" providing implicit
--   typing rules as defined in the YAML 1.2 specification (including
--   support for user-defined custom schemas).</li>
--   <li>Event-based API resembling LibYAML's Event-based API (see
--   <a>Data.YAML.Event</a>).</li>
--   <li>Low-level API access to lexical token-based scanner (see
--   <a>Data.YAML.Token</a>).</li>
--   </ul>
@package HsYAML
@version 0.1.2.0


-- | Tokenizer for the YAML 1.2 syntax as defined in
--   <a>http://yaml.org/spec/1.2/spec.html</a>.
module Data.YAML.Token

-- | <tt><a>tokenize</a> input emit_unparsed</tt> converts the Unicode
--   <i>input</i> (using the UTF-8, UTF-16 (LE or BE), or UTF-32 (LE or BE)
--   encoding) to a list of <a>Token</a> according to the YAML 1.2
--   specification.
--   
--   Errors are reported as tokens with <tt><a>Error</a> ::
--   <a>Code</a></tt>, and the unparsed text following an error may be
--   attached as a final <a>Unparsed</a> token (if the <i>emit_unparsed</i>
--   argument is <tt>True</tt>). Note that tokens are available
--   "immediately", allowing for streaming of large YAML files with memory
--   requirements depending only on the YAML nesting level.
tokenize :: ByteString -> Bool -> [Token]

-- | Parsed token.
data Token
Token :: !Int -> !Int -> !Int -> !Int -> !Code -> !String -> Token

-- | 0-base byte offset in stream.
[tByteOffset] :: Token -> !Int

-- | 0-base character offset in stream.
[tCharOffset] :: Token -> !Int

-- | 1-based line number.
[tLine] :: Token -> !Int

-- | 0-based character in line.
[tLineChar] :: Token -> !Int

-- | Specific token <a>Code</a>.
[tCode] :: Token -> !Code

-- | Contained input chars, if any.
[tText] :: Token -> !String

-- | <a>Token</a> codes.
data Code

-- | BOM, contains "<tt>TF8</tt>", "<tt>TF16LE</tt>", "<tt>TF32BE</tt>",
--   etc.
Bom :: Code

-- | Content text characters.
Text :: Code

-- | Non-content (meta) text characters.
Meta :: Code

-- | Separation line break.
Break :: Code

-- | Line break normalized to content line feed.
LineFeed :: Code

-- | Line break folded to content space.
LineFold :: Code

-- | Character indicating structure.
Indicator :: Code

-- | Separation white space.
White :: Code

-- | Indentation spaces.
Indent :: Code

-- | Document start marker.
DirectivesEnd :: Code

-- | Document end marker.
DocumentEnd :: Code

-- | Begins escape sequence.
BeginEscape :: Code

-- | Ends escape sequence.
EndEscape :: Code

-- | Begins comment.
BeginComment :: Code

-- | Ends comment.
EndComment :: Code

-- | Begins directive.
BeginDirective :: Code

-- | Ends directive.
EndDirective :: Code

-- | Begins tag.
BeginTag :: Code

-- | Ends tag.
EndTag :: Code

-- | Begins tag handle.
BeginHandle :: Code

-- | Ends tag handle.
EndHandle :: Code

-- | Begins anchor.
BeginAnchor :: Code

-- | Ends anchor.
EndAnchor :: Code

-- | Begins node properties.
BeginProperties :: Code

-- | Ends node properties.
EndProperties :: Code

-- | Begins alias.
BeginAlias :: Code

-- | Ends alias.
EndAlias :: Code

-- | Begins scalar content.
BeginScalar :: Code

-- | Ends scalar content.
EndScalar :: Code

-- | Begins sequence content.
BeginSequence :: Code

-- | Ends sequence content.
EndSequence :: Code

-- | Begins mapping content.
BeginMapping :: Code

-- | Ends mapping content.
EndMapping :: Code

-- | Begins mapping key:value pair.
BeginPair :: Code

-- | Ends mapping key:value pair.
EndPair :: Code

-- | Begins complete node.
BeginNode :: Code

-- | Ends complete node.
EndNode :: Code

-- | Begins document.
BeginDocument :: Code

-- | Ends document.
EndDocument :: Code

-- | Begins YAML stream.
BeginStream :: Code

-- | Ends YAML stream.
EndStream :: Code

-- | Parsing error at this point.
Error :: Code

-- | Unparsed due to errors (or at end of test).
Unparsed :: Code

-- | Detected parameter (for testing).
Detected :: Code
instance GHC.Classes.Eq Data.YAML.Token.Decision
instance GHC.Show.Show Data.YAML.Token.Decision
instance GHC.Show.Show Data.YAML.Token.Token
instance GHC.Classes.Eq Data.YAML.Token.Code
instance GHC.Show.Show Data.YAML.Token.Code
instance GHC.Show.Show Data.YAML.Token.Chomp
instance GHC.Read.Read Data.YAML.Token.Chomp
instance GHC.Show.Show Data.YAML.Token.Context
instance GHC.Read.Read Data.YAML.Token.Context
instance Data.YAML.Token.Match (Data.YAML.Token.Parser result) result
instance Data.YAML.Token.Match GHC.Types.Char ()
instance Data.YAML.Token.Match (GHC.Types.Char, GHC.Types.Char) ()
instance Data.YAML.Token.Match GHC.Base.String ()
instance GHC.Show.Show result => GHC.Show.Show (Data.YAML.Token.Result result)
instance GHC.Show.Show result => GHC.Show.Show (Data.YAML.Token.Reply result)
instance GHC.Show.Show Data.YAML.Token.State
instance GHC.Base.Functor Data.YAML.Token.Parser
instance GHC.Base.Applicative Data.YAML.Token.Parser
instance GHC.Base.Monad Data.YAML.Token.Parser
instance GHC.Base.Alternative Data.YAML.Token.Parser


-- | Event-stream oriented YAML parsing API
module Data.YAML.Event

-- | Parse YAML <a>Event</a>s from a lazy <a>ByteString</a>.
--   
--   The input <a>ByteString</a> is expected to have a YAML 1.2 stream
--   using the UTF-8, UTF-16 (LE or BE), or UTF-32 (LE or BE) encodings
--   (which will be auto-detected).
parseEvents :: ByteString -> EvStream

-- | Event stream produced by <a>parseEvents</a>
--   
--   A <a>Left</a> value denotes parsing errors. The event stream ends
--   immediately once a <a>Left</a> value is returned.
type EvStream = [Either (Pos, String) Event]

-- | YAML Event Types
--   
--   The events correspond to the ones from <a>LibYAML</a>
--   
--   The grammar below defines well-formed streams of <a>Event</a>s:
--   
--   <pre>
--   stream   ::= <a>StreamStart</a> document* <a>StreamEnd</a>
--   document ::= <a>DocumentStart</a> node <a>DocumentEnd</a>
--   node     ::= <a>Alias</a>
--              | <a>Scalar</a>
--              | sequence
--              | mapping
--   sequence ::= <a>SequenceStart</a> node* <a>SequenceEnd</a>
--   mapping  ::= <a>MappingStart</a> (node node)* <a>MappingEnd</a>
--   </pre>
data Event
StreamStart :: Event
StreamEnd :: Event
DocumentStart :: !Bool -> Event
DocumentEnd :: !Bool -> Event
Alias :: !Anchor -> Event
Scalar :: !Maybe Anchor -> !Tag -> !Style -> !Text -> Event
SequenceStart :: !Maybe Anchor -> !Tag -> Event
SequenceEnd :: Event
MappingStart :: !Maybe Anchor -> !Tag -> Event
MappingEnd :: Event

-- | <a>Scalar</a> node style
data Style
Plain :: Style
SingleQuoted :: Style
DoubleQuoted :: Style
Literal :: Style
Folded :: Style

-- | YAML Tags
data Tag

-- | An "untagged" YAML tag
untagged :: Tag

-- | Equivalent to <tt>(== <a>untagged</a>)</tt>
isUntagged :: Tag -> Bool

-- | Convert <a>Tag</a> to its string representation
--   
--   Returns <a>Nothing</a> for <a>untagged</a>
tagToText :: Tag -> Maybe Text

-- | Construct YAML tag
mkTag :: String -> Tag

-- | YAML Anchor identifiers
type Anchor = Text

-- | Position in parsed YAML source
data Pos
Pos :: !Int -> !Int -> !Int -> !Int -> Pos

-- | 0-based byte offset
[posByteOffset] :: Pos -> !Int

-- | 0-based character (Unicode code-point) offset
[posCharOffset] :: Pos -> !Int

-- | 1-based line number
[posLine] :: Pos -> !Int

-- | 0-based character (Unicode code-point) column number
[posColumn] :: Pos -> !Int
instance GHC.Classes.Eq Data.YAML.Event.Event
instance GHC.Show.Show Data.YAML.Event.Event
instance GHC.Show.Show Data.YAML.Event.Style
instance GHC.Classes.Ord Data.YAML.Event.Style
instance GHC.Classes.Eq Data.YAML.Event.Style
instance GHC.Show.Show Data.YAML.Event.Pos
instance GHC.Classes.Ord Data.YAML.Event.Tag
instance GHC.Classes.Eq Data.YAML.Event.Tag
instance GHC.Show.Show Data.YAML.Event.Tag


-- | Document oriented <a>YAML</a> parsing API inspired by <a>aeson</a>.
--   
--   <h3>Overview</h3>
--   
--   A <a>yaml.org spec diagram</a> depicts the standard layers of a
--   <a>YAML 1.2</a> processor. This module covers the upper <i>Native</i>
--   and <i>Representation</i> layers, whereas the <a>Data.YAML.Event</a>
--   and <a>Data.YAML.Token</a> modules provide access to the lower
--   <i>Serialization</i> and <i>Presentation</i> layers respectively.
--   
--   <h3>Quick Start Tutorial</h3>
--   
--   Let's assume we want to decode (i.e. <i>load</i>) a simple YAML
--   document
--   
--   <pre>
--   - name: Erik Weisz
--     age: 52
--     magic: True
--   - name: Mina Crandon
--     age: 53
--   </pre>
--   
--   into a native Haskell data structure of type <tt>[Person]</tt>, i.e. a
--   list of <tt>Person</tt> records.
--   
--   The code below shows how to manually define a <tt>Person</tt> record
--   type together with a <a>FromYAML</a> instance:
--   
--   <pre>
--   {-# LANGUAGE OverloadedStrings #-}
--   
--   import Data.YAML
--   
--   data Person = Person
--       { name  :: Text
--       , age   :: Int
--       , magic :: Bool
--       } deriving Show
--   
--   instance FromYAML Person where
--      parseYAML = withMap "Person" $ \m -&gt; Person
--          &lt;$&gt; m .: "name"
--          &lt;*&gt; m .: "age"
--          &lt;*&gt; m .:? "magic" .!= False
--   </pre>
--   
--   And now we can <a>decode</a> the YAML document like so:
--   
--   <pre>
--   &gt;&gt;&gt; decode "- name: Erik Weisz\n  age: 52\n  magic: True\n- name: Mina Crandon\n  age: 53" :: Either String [[Person]]
--   Right [[Person {name = "Erik Weisz", age = 52, magic = True},Person {name = "Mina Crandon", age = 53, magic = False}]]
--   </pre>
module Data.YAML

-- | Decode YAML document(s) using the YAML 1.2 Core schema
--   
--   Each document contained in the YAML stream produce one element of the
--   response list. Here's an example of decoding two concatenated YAML
--   documents:
--   
--   <pre>
--   &gt;&gt;&gt; decode "Foo\n---\nBar" :: Either String [Text]
--   Right ["Foo","Bar"]
--   </pre>
--   
--   Note that an empty stream doesn't contain any (non-comment) document
--   nodes, and therefore results in an empty result list:
--   
--   <pre>
--   &gt;&gt;&gt; decode "# just a comment" :: Either String [Text]
--   Right []
--   </pre>
--   
--   <a>decode</a> uses the same settings as <a>decodeNode</a> for
--   tag-resolving. If you need a different custom parsing configuration,
--   you need to combine <a>parseEither</a> and <a>decodeNode'</a>
--   yourself.
--   
--   The <a>decode</a> as well as the <a>decodeNode</a> functions supports
--   decoding from YAML streams using the UTF-8, UTF-16 (LE or BE), or
--   UTF-32 (LE or BE) encoding (which is auto-detected).
decode :: FromYAML v => ByteString -> Either String [v]

-- | Convenience wrapper over <a>decode</a> expecting exactly one YAML
--   document
--   
--   <pre>
--   &gt;&gt;&gt; decode1 "---\nBar\n..." :: Either String Text
--   Right "Bar"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; decode1 "Foo\n---\nBar" :: Either String Text
--   Left "unexpected multiple YAML documents"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; decode1 "# Just a comment" :: Either String Text
--   Left "empty YAML stream"
--   </pre>
decode1 :: FromYAML v => ByteString -> Either String v

-- | Like <a>decode</a> but takes a strict <a>ByteString</a>
decodeStrict :: FromYAML v => ByteString -> Either String [v]

-- | Like <a>decode1</a> but takes a strict <a>ByteString</a>
decode1Strict :: FromYAML v => ByteString -> Either String v

-- | A type into which YAML nodes can be converted/deserialized
class FromYAML a
parseYAML :: FromYAML a => Node -> Parser a

-- | YAML Parser <a>Monad</a> used by <a>FromYAML</a>
--   
--   See also <a>parseEither</a> or <a>decode</a>
data Parser a

-- | Run <a>Parser</a>
--   
--   A common use-case is <a>parseEither</a> <a>parseYAML</a>.
parseEither :: Parser a -> Either String a

-- | Informative failure helper
--   
--   This is typically used in fall-through cases of <a>parseYAML</a> like
--   so
--   
--   <pre>
--   instance FromYAML ... where
--     parseYAML ...  = ...
--     parseYAML node = typeMismatch "SomeThing" node
--   </pre>
typeMismatch :: String -> Node -> Parser a

-- | YAML mapping
type Mapping = Map Node Node

-- | Retrieve value in <a>Node</a> indexed by a <tt>!!str</tt> <a>Text</a>
--   key.
--   
--   This parser fails if the key doesn't exist.
(.:) :: FromYAML a => Mapping -> Text -> Parser a

-- | Retrieve optional value in <a>Node</a> indexed by a <tt>!!str</tt>
--   <a>Text</a> key.
--   
--   <a>Nothing</a> is returned if the key is missing or points to a
--   <tt>tag:yaml.org,2002:null</tt> node. This combinator only fails if
--   the key exists but cannot be converted to the required type.
--   
--   See also <a>.:!</a>.
(.:?) :: FromYAML a => Mapping -> Text -> Parser (Maybe a)

-- | Retrieve optional value in <a>Node</a> indexed by a <tt>!!str</tt>
--   <a>Text</a> key.
--   
--   <a>Nothing</a> is returned if the key is missing. This combinator only
--   fails if the key exists but cannot be converted to the required type.
--   
--   <b>NOTE</b>: This is a variant of <a>.:?</a> which doesn't map a
--   <tt>tag:yaml.org,2002:null</tt> node to <a>Nothing</a>.
(.:!) :: FromYAML a => Mapping -> Text -> Parser (Maybe a)

-- | Defaulting helper to be used with <a>.:?</a> or <a>.:!</a>.
(.!=) :: Parser (Maybe a) -> a -> Parser a

-- | Operate on <tt>tag:yaml.org,2002:seq</tt> node (or fail)
withSeq :: String -> ([Node] -> Parser a) -> Node -> Parser a

-- | Operate on <tt>tag:yaml.org,2002:bool</tt> node (or fail)
withBool :: String -> (Bool -> Parser a) -> Node -> Parser a

-- | Operate on <tt>tag:yaml.org,2002:float</tt> node (or fail)
withFloat :: String -> (Double -> Parser a) -> Node -> Parser a

-- | Operate on <tt>tag:yaml.org,2002:int</tt> node (or fail)
withInt :: String -> (Integer -> Parser a) -> Node -> Parser a

-- | Operate on <tt>tag:yaml.org,2002:null</tt> node (or fail)
withNull :: String -> Parser a -> Node -> Parser a

-- | Operate on <tt>tag:yaml.org,2002:str</tt> node (or fail)
withStr :: String -> (Text -> Parser a) -> Node -> Parser a

-- | Operate on <tt>tag:yaml.org,2002:seq</tt> node (or fail)
withMap :: String -> (Mapping -> Parser a) -> Node -> Parser a

-- | Parse and decode YAML document(s) into <a>Node</a> graphs
--   
--   This is a convenience wrapper over <a>decodeNode'</a>
--   
--   <pre>
--   decodeNode = decodeNode' coreSchemaResolver False False
--   </pre>
--   
--   In other words,
--   
--   <ul>
--   <li>Use the YAML 1.2 Core schema for resolving</li>
--   <li>Don't create <a>Anchor</a> nodes</li>
--   <li>Disallow cyclic anchor references</li>
--   </ul>
decodeNode :: ByteString -> Either String [Doc Node]

-- | Customizable variant of <a>decodeNode</a>
decodeNode' :: SchemaResolver -> Bool -> Bool -> ByteString -> Either String [Doc Node]

-- | YAML Document tree/graph
newtype Doc n
Doc :: n -> Doc n

-- | YAML Document node
data Node
Scalar :: !Scalar -> Node
Mapping :: !Tag -> Mapping -> Node
Sequence :: !Tag -> [Node] -> Node
Anchor :: !NodeId -> !Node -> Node

-- | Primitive scalar types as defined in YAML 1.2
data Scalar

-- | <pre>
--   tag:yaml.org,2002:null
--   </pre>
SNull :: Scalar

-- | <pre>
--   tag:yaml.org,2002:bool
--   </pre>
SBool :: !Bool -> Scalar

-- | <pre>
--   tag:yaml.org,2002:float
--   </pre>
SFloat :: !Double -> Scalar

-- | <pre>
--   tag:yaml.org,2002:int
--   </pre>
SInt :: !Integer -> Scalar

-- | <pre>
--   tag:yaml.org,2002:str
--   </pre>
SStr :: !Text -> Scalar

-- | unknown/unsupported tag or untagged (thus unresolved) scalar
SUnknown :: !Tag -> !Text -> Scalar

-- | Definition of a <a>YAML 1.2 Schema</a>
--   
--   A YAML schema defines how implicit tags are resolved to concrete tags
--   and how data is represented textually in YAML.
data SchemaResolver
SchemaResolver :: (Tag -> Style -> Text -> Either String Scalar) -> (Tag -> Either String Tag) -> (Tag -> Either String Tag) -> SchemaResolver
[schemaResolverScalar] :: SchemaResolver -> Tag -> Style -> Text -> Either String Scalar
[schemaResolverSequence] :: SchemaResolver -> Tag -> Either String Tag
[schemaResolverMapping] :: SchemaResolver -> Tag -> Either String Tag

-- | "Failsafe" schema resolver as specified in <a>YAML 1.2 / 10.1.2. Tag
--   Resolution</a>
failsafeSchemaResolver :: SchemaResolver

-- | Strict JSON schema resolver as specified in <a>YAML 1.2 / 10.2.2. Tag
--   Resolution</a>
jsonSchemaResolver :: SchemaResolver

-- | Core schema resolver as specified in <a>YAML 1.2 / 10.3.2. Tag
--   Resolution</a>
coreSchemaResolver :: SchemaResolver

-- | Generalised document tree/graph construction
--   
--   This doesn't yet perform any tag resolution (thus all scalars are
--   represented as <a>Text</a> values). See also <tt>decodeNode</tt> for a
--   more convenient interface.
decodeLoader :: forall n m. MonadFix m => Loader m n -> ByteString -> m (Either String [n])

-- | Structure defining how to construct a document tree/graph
data Loader m n
Loader :: (Tag -> Style -> Text -> m (Either String n)) -> (Tag -> [n] -> m (Either String n)) -> (Tag -> [(n, n)] -> m (Either String n)) -> (NodeId -> Bool -> n -> m (Either String n)) -> (NodeId -> n -> m (Either String n)) -> Loader m n
[yScalar] :: Loader m n -> Tag -> Style -> Text -> m (Either String n)
[ySequence] :: Loader m n -> Tag -> [n] -> m (Either String n)
[yMapping] :: Loader m n -> Tag -> [(n, n)] -> m (Either String n)
[yAlias] :: Loader m n -> NodeId -> Bool -> n -> m (Either String n)
[yAnchor] :: Loader m n -> NodeId -> n -> m (Either String n)

-- | Unique identifier for identifying nodes
--   
--   This is allows to observe the alias/anchor-reference structure
type NodeId = Word
instance GHC.Show.Show Data.YAML.Node
instance GHC.Classes.Ord Data.YAML.Node
instance GHC.Classes.Eq Data.YAML.Node
instance GHC.Show.Show n => GHC.Show.Show (Data.YAML.Doc n)
instance GHC.Classes.Ord n => GHC.Classes.Ord (Data.YAML.Doc n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Data.YAML.Doc n)
instance Data.YAML.FromYAML Data.YAML.Node
instance Data.YAML.FromYAML GHC.Types.Bool
instance Data.YAML.FromYAML Data.Text.Internal.Text
instance Data.YAML.FromYAML GHC.Integer.Type.Integer
instance Data.YAML.FromYAML GHC.Natural.Natural
instance Data.YAML.FromYAML GHC.Types.Int
instance Data.YAML.FromYAML GHC.Int.Int8
instance Data.YAML.FromYAML GHC.Int.Int16
instance Data.YAML.FromYAML GHC.Int.Int32
instance Data.YAML.FromYAML GHC.Int.Int64
instance Data.YAML.FromYAML GHC.Types.Word
instance Data.YAML.FromYAML GHC.Word.Word8
instance Data.YAML.FromYAML GHC.Word.Word16
instance Data.YAML.FromYAML GHC.Word.Word32
instance Data.YAML.FromYAML GHC.Word.Word64
instance Data.YAML.FromYAML GHC.Types.Double
instance (GHC.Classes.Ord k, Data.YAML.FromYAML k, Data.YAML.FromYAML v) => Data.YAML.FromYAML (Data.Map.Internal.Map k v)
instance Data.YAML.FromYAML v => Data.YAML.FromYAML [v]
instance Data.YAML.FromYAML a => Data.YAML.FromYAML (GHC.Maybe.Maybe a)
instance (Data.YAML.FromYAML a, Data.YAML.FromYAML b) => Data.YAML.FromYAML (a, b)
instance (Data.YAML.FromYAML a, Data.YAML.FromYAML b, Data.YAML.FromYAML c) => Data.YAML.FromYAML (a, b, c)
instance (Data.YAML.FromYAML a, Data.YAML.FromYAML b, Data.YAML.FromYAML c, Data.YAML.FromYAML d) => Data.YAML.FromYAML (a, b, c, d)
instance (Data.YAML.FromYAML a, Data.YAML.FromYAML b, Data.YAML.FromYAML c, Data.YAML.FromYAML d, Data.YAML.FromYAML e) => Data.YAML.FromYAML (a, b, c, d, e)
instance (Data.YAML.FromYAML a, Data.YAML.FromYAML b, Data.YAML.FromYAML c, Data.YAML.FromYAML d, Data.YAML.FromYAML e, Data.YAML.FromYAML f) => Data.YAML.FromYAML (a, b, c, d, e, f)
instance (Data.YAML.FromYAML a, Data.YAML.FromYAML b, Data.YAML.FromYAML c, Data.YAML.FromYAML d, Data.YAML.FromYAML e, Data.YAML.FromYAML f, Data.YAML.FromYAML g) => Data.YAML.FromYAML (a, b, c, d, e, f, g)
instance GHC.Base.Functor Data.YAML.Parser
instance GHC.Base.Applicative Data.YAML.Parser
instance GHC.Base.Monad Data.YAML.Parser
instance Control.Monad.Fail.MonadFail Data.YAML.Parser
instance GHC.Base.Alternative Data.YAML.Parser
instance GHC.Base.MonadPlus Data.YAML.Parser
