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

-- | Support for parsing and rendering YAML documents.
--   
--   README and API documentation are available at
--   https://www.stackage.org/package/yaml
@package yaml
@version 0.11.11.2

module Data.Yaml.Internal
data ParseException
NonScalarKey :: ParseException
UnknownAlias :: AnchorName -> ParseException
[_anchorName] :: ParseException -> AnchorName
UnexpectedEvent :: Maybe Event -> Maybe Event -> ParseException
[_received] :: ParseException -> Maybe Event
[_expected] :: ParseException -> Maybe Event
InvalidYaml :: Maybe YamlException -> ParseException
MultipleDocuments :: ParseException
AesonException :: String -> ParseException
OtherParseException :: SomeException -> ParseException
NonStringKey :: JSONPath -> ParseException
NonStringKeyAlias :: AnchorName -> Value -> ParseException
CyclicIncludes :: ParseException
LoadSettingsException :: FilePath -> ParseException -> ParseException

-- | Alternative to show to display a ParseException on the
--   screen. Instead of displaying the data constructors applied to their
--   arguments, a more textual output is returned. For example, instead of
--   printing:
--   
--   
--   InvalidYaml (Just (YamlParseException {yamlProblem = "did not find expected ',' or '}'", yamlContext = "while parsing a flow mapping", yamlProblemMark = YamlMark {yamlIndex = 42, yamlLine = 2, yamlColumn = 12}})))
--   
--   
--   It looks more pleasant to print:
--   
--   
--   YAML parse exception at line 2, column 12,
--   while parsing a flow mapping:
--   did not find expected ',' or '}'
--   
--   
--   Since 0.8.11
prettyPrintParseException :: ParseException -> String
data Warning
DuplicateKey :: JSONPath -> Warning
parse :: ReaderT JSONPath (ConduitM Event o Parse) Value
type Parse = StateT ParseState ResourceT IO
decodeHelper :: FromJSON a => ConduitM () Event Parse () -> IO (Either ParseException ([Warning], Either String a))
decodeHelper_ :: FromJSON a => ConduitM () Event Parse () -> IO (Either ParseException ([Warning], a))
decodeAllHelper :: FromJSON a => ConduitM () Event Parse () -> IO (Either ParseException ([Warning], Either String [a]))
decodeAllHelper_ :: FromJSON a => ConduitM () Event Parse () -> IO (Either ParseException ([Warning], [a]))
textToScientific :: Text -> Either String Scientific

-- | Encodes a string with the supplied style. This function handles the
--   empty string case properly to avoid
--   https://github.com/snoyberg/yaml/issues/24
stringScalar :: StringStyle -> Maybe Text -> Text -> Event
type StringStyle = Text -> (Tag, Style)

defaultStringStyle :: StringStyle

-- | Determine whether a string must be quoted in YAML and can't appear as
--   plain text. Useful if you want to use setStringStyle.
isSpecialString :: Text -> Bool

-- | Strings which must be escaped so as not to be treated as non-string
--   scalars.
specialStrings :: HashSet Text

isNumeric :: Text -> Bool

-- | Encode a value as a YAML document stream.
objToStream :: ToJSON a => StringStyle -> a -> [Event]

-- | Encode a value as a list of Events.
objToEvents :: ToJSON a => StringStyle -> a -> [Event] -> [Event]
instance GHC.Classes.Eq Data.Yaml.Internal.Warning
instance GHC.Internal.Exception.Type.Exception Data.Yaml.Internal.ParseException
instance GHC.Internal.Show.Show Data.Yaml.Internal.ParseException
instance GHC.Internal.Show.Show Data.Yaml.Internal.Warning

module Data.Yaml.Include

-- | Like decodeFile but with support for relative and absolute
--   includes.
--   
--   The syntax for includes follows the form:
--   
--   
--   somekey: !include ./somefile.yaml
--   
decodeFile :: FromJSON a => FilePath -> IO (Maybe a)

-- | Like decodeFileEither but with support for relative and
--   absolute includes.
--   
--   The syntax for includes follows the form:
--   
--   
--   somekey: !include ./somefile.yaml
--   
decodeFileEither :: FromJSON a => FilePath -> IO (Either ParseException a)

-- | A version of decodeFileEither that returns warnings along with
--   the parse result.
decodeFileWithWarnings :: FromJSON a => FilePath -> IO (Either ParseException ([Warning], a))

-- | drastically, or be entirely removed, in a future release.
module Data.Yaml.Builder
newtype YamlBuilder
YamlBuilder :: ([Event] -> [Event]) -> YamlBuilder
[unYamlBuilder] :: YamlBuilder -> [Event] -> [Event]
class ToYaml a
toYaml :: ToYaml a => a -> YamlBuilder

mapping :: [(Text, YamlBuilder)] -> YamlBuilder

namedMapping :: Text -> [(Text, YamlBuilder)] -> YamlBuilder

maybeNamedMapping :: Maybe Text -> [(Text, YamlBuilder)] -> YamlBuilder

mappingComplex :: [(YamlBuilder, YamlBuilder)] -> YamlBuilder

namedMappingComplex :: Text -> [(YamlBuilder, YamlBuilder)] -> YamlBuilder

maybeNamedMappingComplex :: Maybe Text -> [(YamlBuilder, YamlBuilder)] -> YamlBuilder

array :: [YamlBuilder] -> YamlBuilder

namedArray :: Text -> [YamlBuilder] -> YamlBuilder

maybeNamedArray :: Maybe Text -> [YamlBuilder] -> YamlBuilder

string :: Text -> YamlBuilder

namedString :: Text -> Text -> YamlBuilder

maybeNamedString :: Maybe Text -> Text -> YamlBuilder

bool :: Bool -> YamlBuilder

namedBool :: Text -> Bool -> YamlBuilder

maybeNamedBool :: Maybe Text -> Bool -> YamlBuilder

null :: YamlBuilder

namedNull :: Text -> YamlBuilder

maybeNamedNull :: Maybe Text -> YamlBuilder

scientific :: Scientific -> YamlBuilder

namedScientific :: Text -> Scientific -> YamlBuilder

maybeNamedScientific :: Maybe Text -> Scientific -> YamlBuilder

alias :: Text -> YamlBuilder

-- | Deprecated: Use scientific
number :: Scientific -> YamlBuilder

toByteString :: ToYaml a => a -> ByteString

toByteStringWith :: ToYaml a => FormatOptions -> a -> ByteString
writeYamlFile :: ToYaml a => FilePath -> a -> IO ()

writeYamlFileWith :: ToYaml a => FormatOptions -> FilePath -> a -> IO ()
(.=) :: ToYaml a => Text -> a -> (Text, YamlBuilder)

-- | Contains options relating to the formatting (indendation, width) of
--   the YAML output.
data FormatOptions

-- | Set the maximum number of columns in the YAML output, or
--   Nothing for infinite. By default, the limit is 80 characters.
setWidth :: Maybe Int -> FormatOptions -> FormatOptions
instance Data.Yaml.Builder.ToYaml GHC.Types.Bool
instance Data.Yaml.Builder.ToYaml GHC.Types.Double
instance Data.Yaml.Builder.ToYaml GHC.Types.Int
instance (Data.Yaml.Builder.ToYaml a, Data.Yaml.Builder.ToYaml b) => Data.Yaml.Builder.ToYaml [(a, b)]
instance Data.Yaml.Builder.ToYaml a => Data.Yaml.Builder.ToYaml [a]
instance Data.Yaml.Builder.ToYaml GHC.Internal.Base.String
instance Data.Yaml.Builder.ToYaml a => Data.Yaml.Builder.ToYaml (GHC.Internal.Maybe.Maybe a)
instance Data.Yaml.Builder.ToYaml Data.Scientific.Scientific
instance Data.Yaml.Builder.ToYaml Data.Text.Internal.Text
instance Data.Yaml.Builder.ToYaml Data.Yaml.Builder.YamlBuilder

-- | Provides a high-level interface for processing YAML files.
--   
--   This module reuses most of the infrastructure from the aeson
--   package. This means that you can use all of the existing tools for
--   JSON processing for processing YAML files. As a result, much of the
--   documentation below mentions JSON; do not let that confuse you, it's
--   intentional.
--   
--   For the most part, YAML content translates directly into JSON, and
--   therefore there is very little data loss. If you need to deal with
--   YAML more directly (e.g., directly deal with aliases), you should use
--   the Text.Libyaml module instead.
--   
--   For documentation on the aeson types, functions, classes, and
--   operators, please see the Data.Aeson module of the
--   aeson package.
--   
--   Look in the examples directory of the source repository for some
--   initial pointers on how to use this library.
module Data.Yaml

-- | Encode a value into its YAML representation.
encode :: ToJSON a => a -> ByteString

-- | Encode a value into its YAML representation with custom styling.
encodeWith :: ToJSON a => EncodeOptions -> a -> ByteString

-- | Encode a value into its YAML representation and save to the given
--   file.
encodeFile :: ToJSON a => FilePath -> a -> IO ()

-- | Encode a value into its YAML representation with custom styling and
--   save to the given file.
encodeFileWith :: ToJSON a => EncodeOptions -> FilePath -> a -> IO ()

-- | More helpful version of decodeEither which returns the
--   YamlException.
decodeEither' :: FromJSON a => ByteString -> Either ParseException a

-- | A version of decodeFile which should not throw runtime
--   exceptions.
decodeFileEither :: FromJSON a => FilePath -> IO (Either ParseException a)

-- | A version of decodeFileEither that returns warnings along with
--   the parse result.
decodeFileWithWarnings :: FromJSON a => FilePath -> IO (Either ParseException ([Warning], a))

-- | A version of decodeEither' lifted to MonadThrow
decodeThrow :: (MonadThrow m, FromJSON a) => ByteString -> m a

-- | A version of decodeFileEither lifted to MonadIO
decodeFileThrow :: (MonadIO m, FromJSON a) => FilePath -> m a

-- | Like decodeEither', but decode multiple documents.
decodeAllEither' :: FromJSON a => ByteString -> Either ParseException [a]

-- | Like decodeFileEither, but decode multiple documents.
decodeAllFileEither :: FromJSON a => FilePath -> IO (Either ParseException [a])

-- | Like decodeFileWithWarnings, but decode multiple documents.
decodeAllFileWithWarnings :: FromJSON a => FilePath -> IO (Either ParseException ([Warning], [a]))

-- | Like decodeThrow, but decode multiple documents.
decodeAllThrow :: (MonadThrow m, FromJSON a) => ByteString -> m [a]

-- | Like decodeFileThrow, but decode multiple documents.
decodeAllFileThrow :: (MonadIO m, FromJSON a) => FilePath -> m [a]
decodeHelper :: FromJSON a => ConduitM () Event Parse () -> IO (Either ParseException ([Warning], Either String a))

-- | A JSON value represented as a Haskell value.
data Value
Object :: !Object -> Value
Array :: !Array -> Value
String :: !Text -> Value
Number :: !Scientific -> Value
Bool :: !Bool -> Value
Null :: Value

-- | A JSON parser. N.B. This might not fit your usual understanding of
--   "parser". Instead you might like to think of Parser as a "parse
--   result", i.e. a parser to which the input has already been applied.
data Parser a

-- | A JSON "object" (key/value map).
type Object = KeyMap Value

-- | A JSON "array" (sequence).
type Array = Vector Value
data ParseException
NonScalarKey :: ParseException
UnknownAlias :: AnchorName -> ParseException
[_anchorName] :: ParseException -> AnchorName
UnexpectedEvent :: Maybe Event -> Maybe Event -> ParseException
[_received] :: ParseException -> Maybe Event
[_expected] :: ParseException -> Maybe Event
InvalidYaml :: Maybe YamlException -> ParseException
MultipleDocuments :: ParseException
AesonException :: String -> ParseException
OtherParseException :: SomeException -> ParseException
NonStringKey :: JSONPath -> ParseException
NonStringKeyAlias :: AnchorName -> Value -> ParseException
CyclicIncludes :: ParseException
LoadSettingsException :: FilePath -> ParseException -> ParseException

-- | Alternative to show to display a ParseException on the
--   screen. Instead of displaying the data constructors applied to their
--   arguments, a more textual output is returned. For example, instead of
--   printing:
--   
--   
--   InvalidYaml (Just (YamlParseException {yamlProblem = "did not find expected ',' or '}'", yamlContext = "while parsing a flow mapping", yamlProblemMark = YamlMark {yamlIndex = 42, yamlLine = 2, yamlColumn = 12}})))
--   
--   
--   It looks more pleasant to print:
--   
--   
--   YAML parse exception at line 2, column 12,
--   while parsing a flow mapping:
--   did not find expected ',' or '}'
--   
--   
--   Since 0.8.11
prettyPrintParseException :: ParseException -> String
data YamlException
YamlException :: String -> YamlException

-- | problem, context, index, position line, position column
YamlParseException :: String -> String -> YamlMark -> YamlException
[yamlProblem] :: YamlException -> String
[yamlContext] :: YamlException -> String
[yamlProblemMark] :: YamlException -> YamlMark

-- | The pointer position
data YamlMark
YamlMark :: Int -> Int -> Int -> YamlMark
[yamlIndex] :: YamlMark -> Int
[yamlLine] :: YamlMark -> Int
[yamlColumn] :: YamlMark -> Int

-- | Create a Value from a list of name/value Pairs. If
--   duplicate keys arise, later keys and their associated values win.
object :: [Pair] -> Value

-- | Construct a new Value from a list of Values.
array :: [Value] -> Value
(.=) :: (KeyValue e kv, ToJSON v) => Key -> v -> kv
infixr 8 .=

-- | Retrieve the value associated with the given key of an Object.
--   The result is empty if the key is not present or the value
--   cannot be converted to the desired type.
--   
--   This accessor is appropriate if the key and value must be
--   present in an object for it to be valid. If the key and value are
--   optional, use .:? instead.
(.:) :: FromJSON a => Object -> Key -> Parser a

-- | Retrieve the value associated with the given key of an Object.
--   The result is Nothing if the key is not present or if its value
--   is Null, or empty if the value cannot be converted to
--   the desired type.
--   
--   This accessor is most useful if the key and value can be absent from
--   an object without affecting its validity. If the key and value are
--   mandatory, use .: instead.
(.:?) :: FromJSON a => Object -> Key -> Parser (Maybe a)

-- | Helper for use in combination with .:? to provide default
--   values for optional JSON object fields.
--   
--   This combinator is most useful if the key and value can be absent from
--   an object without affecting its validity and we know a default value
--   to assign in that case. If the key and value are mandatory, use
--   .: instead.
--   
--   Example usage:
--   
--   
--   v1 <- o .:? "opt_field_with_dfl" .!= "default_val"
--   v2 <- o .:  "mandatory_field"
--   v3 <- o .:? "opt_field2"
--   
(.!=) :: Parser (Maybe a) -> a -> Parser a

-- | withObject name f value applies f to the
--   Object when value is an Object and fails
--   otherwise.
--   
--   
Error message example
--   
--   
--   withObject "MyType" f (String "oops")
--   -- Error: "parsing MyType failed, expected Object, but encountered String"
--   
withObject :: String -> (Object -> Parser a) -> Value -> Parser a

-- | withText name f value applies f to the
--   Text when value is a String and fails
--   otherwise.
--   
--   
Error message example
--   
--   
--   withText "MyType" f Null
--   -- Error: "parsing MyType failed, expected String, but encountered Null"
--   
withText :: String -> (Text -> Parser a) -> Value -> Parser a

-- | withArray expected f value applies f to the
--   Array when value is an Array and fails
--   otherwise.
--   
--   
Error message example
--   
--   
--   withArray "MyType" f (String "oops")
--   -- Error: "parsing MyType failed, expected Array, but encountered String"
--   
withArray :: String -> (Array -> Parser a) -> Value -> Parser a

-- | withScientific name f value applies f to the
--   Scientific number when value is a Number and
--   fails using typeMismatch otherwise.
--   
--   Warning: If you are converting from a scientific to an
--   unbounded type such as Integer you may want to add a
--   restriction on the size of the exponent (see
--   withBoundedScientific) to prevent malicious input from filling
--   up the memory of the target system.
--   
--   
Error message example
--   
--   
--   withScientific "MyType" f (String "oops")
--   -- Error: "parsing MyType failed, expected Number, but encountered String"
--   
withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a

-- | withBool expected f value applies f to the
--   Bool when value is a Boolean and fails
--   otherwise.
--   
--   
Error message example
--   
--   
--   withBool "MyType" f (String "oops")
--   -- Error: "parsing MyType failed, expected Boolean, but encountered String"
--   
withBool :: String -> (Bool -> Parser a) -> Value -> Parser a

-- | Deprecated: With the MonadFail split, this function is going to be
--   removed in the future. Please migrate to parseEither.
parseMonad :: MonadFail m => (a -> Parser b) -> a -> m b

-- | Run a Parser with an Either result type. If the parse
--   fails, the Left payload will contain an error message.
parseEither :: (a -> Parser b) -> a -> Either String b

-- | Run a Parser with a Maybe result type.
parseMaybe :: (a -> Parser b) -> a -> Maybe b

-- | A type that can be converted to JSON.
--   
--   Instances in general must specify toJSON and
--   should (but don't need to) specify toEncoding.
--   
--   An example type and instance:
--   
--   
--   -- Allow ourselves to write Text literals.
--   {-# LANGUAGE OverloadedStrings #-}
--   
--   data Coord = Coord { x :: Double, y :: Double }
--   
--   instance ToJSON Coord where
--     toJSON (Coord x y) = object ["x" .= x, "y" .= y]
--   
--     toEncoding (Coord x y) = pairs ("x" .= x <> "y" .= y)
--   
--   
--   Instead of manually writing your ToJSON instance, there are two
--   options to do it automatically:
--   
--   
--   
- Data.Aeson.TH provides Template Haskell functions which
--   will derive an instance at compile time. The generated instance is
--   optimized for your type so it will probably be more efficient than the
--   following option.
--   
- The compiler can provide a default generic implementation for
--   toJSON.
--   
--   
--   To use the second, simply add a deriving Generic
--   clause to your datatype and declare a ToJSON instance. If you
--   require nothing other than defaultOptions, it is sufficient to
--   write (and this is the only alternative where the default
--   toJSON implementation is sufficient):
--   
--   
--   {-# LANGUAGE DeriveGeneric #-}
--   
--   import GHC.Generics
--   
--   data Coord = Coord { x :: Double, y :: Double } deriving Generic
--   
--   instance ToJSON Coord where
--       toEncoding = genericToEncoding defaultOptions
--   
--   
--   or more conveniently using the DerivingVia extension
--   
--   
--   deriving via Generically Coord instance ToJSON Coord
--   
--   
--   If on the other hand you wish to customize the generic decoding, you
--   have to implement both methods:
--   
--   
--   customOptions = defaultOptions
--                   { fieldLabelModifier = map toUpper
--                   }
--   
--   instance ToJSON Coord where
--       toJSON     = genericToJSON customOptions
--       toEncoding = genericToEncoding customOptions
--   
--   
--   Previous versions of this library only had the toJSON method.
--   Adding toEncoding had two reasons:
--   
--   
--   
- toEncoding is more efficient for the common case that the
--   output of toJSON is directly serialized to a
--   ByteString. Further, expressing either method in terms of the
--   other would be non-optimal.
--   
- The choice of defaults allows a smooth transition for existing
--   users: Existing instances that do not define toEncoding still
--   compile and have the correct semantics. This is ensured by making the
--   default implementation of toEncoding use toJSON. This
--   produces correct results, but since it performs an intermediate
--   conversion to a Value, it will be less efficient than directly
--   emitting an Encoding. (this also means that specifying nothing
--   more than instance ToJSON Coord would be sufficient as a
--   generically decoding instance, but there probably exists no good
--   reason to not specify toEncoding in new instances.)
--   
class ToJSON a

-- | Convert a Haskell value to a JSON-friendly intermediate type.
toJSON :: ToJSON a => a -> Value
($dmtoJSON) :: (ToJSON a, Generic a, GToJSON' Value Zero (Rep a)) => a -> Value

-- | Encode a Haskell value as JSON.
--   
--   The default implementation of this method creates an intermediate
--   Value using toJSON. This provides source-level
--   compatibility for people upgrading from older versions of this
--   library, but obviously offers no performance advantage.
--   
--   To benefit from direct encoding, you must provide an
--   implementation for this method. The easiest way to do so is by having
--   your types implement Generic using the DeriveGeneric
--   extension, and then have GHC generate a method body as follows.
--   
--   
--   instance ToJSON Coord where
--       toEncoding = genericToEncoding defaultOptions
--   
toEncoding :: ToJSON a => a -> Encoding
toJSONList :: ToJSON a => [a] -> Value
toEncodingList :: ToJSON a => [a] -> Encoding

-- | Defines when it is acceptable to omit a field of this type from a
--   record. Used by (.?=) operator, and Generics and TH
--   deriving with omitNothingFields = True.
omitField :: ToJSON a => a -> Bool

-- | A type that can be converted from JSON, with the possibility of
--   failure.
--   
--   In many cases, you can get the compiler to generate parsing code for
--   you (see below). To begin, let's cover writing an instance by hand.
--   
--   There are various reasons a conversion could fail. For example, an
--   Object could be missing a required key, an Array could
--   be of the wrong size, or a value could be of an incompatible type.
--   
--   The basic ways to signal a failed conversion are as follows:
--   
--   
--   
- fail yields a custom error message: it is the recommended
--   way of reporting a failure;
--   
- empty (or mzero) is uninformative: use it when the
--   error is meant to be caught by some (<|>);
--   
- typeMismatch can be used to report a failure when the
--   encountered value is not of the expected JSON type; unexpected
--   is an appropriate alternative when more than one type may be expected,
--   or to keep the expected type implicit.
--   
--   
--   prependFailure (or modifyFailure) add more information
--   to a parser's error messages.
--   
--   An example type and instance using typeMismatch and
--   prependFailure:
--   
--   
--   -- Allow ourselves to write Text literals.
--   {-# LANGUAGE OverloadedStrings #-}
--   
--   data Coord = Coord { x :: Double, y :: Double }
--   
--   instance FromJSON Coord where
--       parseJSON (Object v) = Coord
--           <$> v .: "x"
--           <*> v .: "y"
--   
--       -- We do not expect a non-Object value here.
--       -- We could use empty to fail, but typeMismatch
--       -- gives a much more informative error message.
--       parseJSON invalid    =
--           prependFailure "parsing Coord failed, "
--               (typeMismatch "Object" invalid)
--   
--   
--   For this common case of only being concerned with a single type of
--   JSON value, the functions withObject, withScientific,
--   etc. are provided. Their use is to be preferred when possible, since
--   they are more terse. Using withObject, we can rewrite the above
--   instance (assuming the same language extension and data type) as:
--   
--   
--   instance FromJSON Coord where
--       parseJSON = withObject "Coord" $ \v -> Coord
--           <$> v .: "x"
--           <*> v .: "y"
--   
--   
--   Instead of manually writing your FromJSON instance, there are
--   two options to do it automatically:
--   
--   
--   
- Data.Aeson.TH provides Template Haskell functions which
--   will derive an instance at compile time. The generated instance is
--   optimized for your type so it will probably be more efficient than the
--   following option.
--   
- The compiler can provide a default generic implementation for
--   parseJSON.
--   
--   
--   To use the second, simply add a deriving Generic
--   clause to your datatype and declare a FromJSON instance for
--   your datatype without giving a definition for parseJSON.
--   
--   For example, the previous example can be simplified to just:
--   
--   
--   {-# LANGUAGE DeriveGeneric #-}
--   
--   import GHC.Generics
--   
--   data Coord = Coord { x :: Double, y :: Double } deriving Generic
--   
--   instance FromJSON Coord
--   
--   
--   or using the DerivingVia extension
--   
--   
--   deriving via Generically Coord instance FromJSON Coord
--   
--   
--   The default implementation will be equivalent to parseJSON =
--   genericParseJSON defaultOptions; if you need
--   different options, you can customize the generic decoding by defining:
--   
--   
--   customOptions = defaultOptions
--                   { fieldLabelModifier = map toUpper
--                   }
--   
--   instance FromJSON Coord where
--       parseJSON = genericParseJSON customOptions
--   
class FromJSON a
parseJSON :: FromJSON a => Value -> Parser a
($dmparseJSON) :: (FromJSON a, Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a
parseJSONList :: FromJSON a => Value -> Parser [a]

-- | Default value for optional fields. Used by (.:?=)
--   operator, and Generics and TH deriving with
--   allowOmittedFields = True (default).
omittedField :: FromJSON a => Maybe a

-- | Determine whether a string must be quoted in YAML and can't appear as
--   plain text. Useful if you want to use setStringStyle.
isSpecialString :: Text -> Bool

data EncodeOptions

defaultEncodeOptions :: EncodeOptions

defaultStringStyle :: StringStyle

-- | Set the string style in the encoded YAML. This is a function that
--   decides for each string the type of YAML string to output.
--   
--   WARNING: You must ensure that special strings (like
--   "yes"/"no"/"null"/"1234") are not
--   encoded with the Plain style, because then they will be decoded
--   as boolean, null or numeric values. You can use isSpecialString
--   to detect them.
--   
--   By default, strings are encoded as follows:
--   
--   
--   
- Any string containing a newline character uses the Literal
--   style
--   
- Otherwise, any special string (see isSpecialString) uses
--   SingleQuoted
--   
- Otherwise, use Plain
--   
setStringStyle :: (Text -> (Tag, Style)) -> EncodeOptions -> EncodeOptions

-- | Set the encoding formatting for the encoded YAML. By default, this is
--   defaultFormatOptions.
setFormat :: FormatOptions -> EncodeOptions -> EncodeOptions

-- | Contains options relating to the formatting (indendation, width) of
--   the YAML output.
data FormatOptions

defaultFormatOptions :: FormatOptions

-- | Set the maximum number of columns in the YAML output, or
--   Nothing for infinite. By default, the limit is 80 characters.
setWidth :: Maybe Int -> FormatOptions -> FormatOptions

-- | Deprecated: Please use decodeEither or decodeThrow, which provide
--   information on how the decode failed
decode :: FromJSON a => ByteString -> Maybe a

-- | Deprecated: Please use decodeFileEither, which does not confused
--   type-directed and runtime exceptions.
decodeFile :: FromJSON a => FilePath -> IO (Maybe a)

-- | Deprecated: Please use decodeEither' or decodeThrow, which provide
--   more useful failures
decodeEither :: FromJSON a => ByteString -> Either String a

-- | Functionality for using YAML as configuration files
--   
--   In particular, merging environment variables with yaml values
--   
--   loadYamlSettings is a high-level API for loading YAML and
--   merging environment variables. A yaml value of
--   _env:ENV_VAR:default will lookup the environment variable
--   ENV_VAR.
--   
--   On a historical note, this code was taken directly from the yesod web
--   framework's configuration module.
module Data.Yaml.Config

-- | Load the settings from the following three sources:
--   
--   
--   
- Run time config files
--   
- Run time environment variables
--   
- The default compile time config file
--   
--   
--   For example, to load up settings from config/foo.yaml and
--   allow overriding from the actual environment, you can use:
--   
--   
--   loadYamlSettings ["config/foo.yaml"] [] useEnv
--   
loadYamlSettings :: FromJSON settings => [FilePath] -> [Value] -> EnvUsage -> IO settings

-- | Same as loadYamlSettings, but get the list of runtime config
--   files from the command line arguments.
loadYamlSettingsArgs :: FromJSON settings => [Value] -> EnvUsage -> IO settings

-- | Defines how we want to use the environment variables when loading a
--   config file. Use the smart constructors provided by this module.
data EnvUsage

-- | Do not use any environment variables, instead relying on defaults
--   values in the config file.
ignoreEnv :: EnvUsage

-- | Use environment variables when available, otherwise use defaults.
useEnv :: EnvUsage

-- | Do not use default values from the config file, but instead take all
--   overrides from the environment. If a value is missing, loading the
--   file will throw an exception.
requireEnv :: EnvUsage

-- | Same as useEnv, but instead of the actual environment, use the
--   provided HashMap as the environment.
useCustomEnv :: KeyMap Text -> EnvUsage

-- | Same as requireEnv, but instead of the actual environment, use
--   the provided HashMap as the environment.
requireCustomEnv :: KeyMap Text -> EnvUsage

-- | A convenience wrapper around applyEnvValue and
--   getCurrentEnv
applyCurrentEnv :: Bool -> Value -> IO Value

-- | Get the actual environment as a HashMap from Text to
--   Text.
getCurrentEnv :: IO (KeyMap Text)

-- | Override environment variable placeholders in the given Value
--   with values from the environment.
--   
--   If the first argument is True, then all placeholders _must_
--   be provided by the actual environment. Otherwise, default values from
--   the Value will be used.
applyEnvValue :: Bool -> KeyMap Text -> Value -> Value
instance GHC.Internal.Base.Semigroup Data.Yaml.Config.MergedValue

-- | Just a re-export of Data.Yaml. In the future, this will be
--   the canonical name for that module's contents.
module Data.Yaml.Aeson

-- | drastically, or be entirely removed, in a future release.
module Data.Yaml.Parser
newtype YamlParser a
YamlParser :: (AnchorMap -> Either Text a) -> YamlParser a
[unYamlParser] :: YamlParser a -> AnchorMap -> Either Text a
lookupAnchor :: AnchorName -> YamlParser (Maybe YamlValue)
withAnchor :: AnchorName -> Text -> (YamlValue -> YamlParser a) -> YamlParser a
withMapping :: Text -> ([(Text, YamlValue)] -> YamlParser a) -> YamlValue -> YamlParser a
withSequence :: Text -> ([YamlValue] -> YamlParser a) -> YamlValue -> YamlParser a
withText :: Text -> (Text -> YamlParser a) -> YamlValue -> YamlParser a
typeMismatch :: Text -> YamlValue -> YamlParser a
class FromYaml a
fromYaml :: FromYaml a => YamlValue -> YamlParser a
data YamlValue
Mapping :: [(Text, YamlValue)] -> Anchor -> YamlValue
Sequence :: [YamlValue] -> Anchor -> YamlValue
Scalar :: ByteString -> Tag -> Style -> Anchor -> YamlValue
Alias :: AnchorName -> YamlValue
type AnchorMap = Map AnchorName YamlValue
data RawDoc
RawDoc :: YamlValue -> AnchorMap -> RawDoc
parseRawDoc :: (FromYaml a, MonadThrow m) => RawDoc -> m a
(.:) :: FromYaml a => [(Text, YamlValue)] -> Text -> YamlParser a
data YamlParseException
UnexpectedEndOfEvents :: YamlParseException
UnexpectedEvent :: Event -> YamlParseException
FromYamlException :: Text -> YamlParseException
sinkValue :: forall (m :: Type -> Type) o. MonadThrow m => ConduitM Event o (WriterT AnchorMap m) YamlValue
sinkRawDoc :: forall (m :: Type -> Type) o. MonadThrow m => ConduitM Event o m RawDoc
readYamlFile :: FromYaml a => FilePath -> IO a
instance GHC.Internal.Base.Alternative Data.Yaml.Parser.YamlParser
instance GHC.Internal.Base.Applicative Data.Yaml.Parser.YamlParser
instance GHC.Internal.Exception.Type.Exception Data.Yaml.Parser.YamlParseException
instance Data.Yaml.Parser.FromYaml GHC.Types.Int
instance Data.Yaml.Parser.FromYaml a => Data.Yaml.Parser.FromYaml [a]
instance Data.Yaml.Parser.FromYaml Data.Text.Internal.Text
instance Data.Yaml.Parser.FromYaml Data.Yaml.Parser.YamlValue
instance GHC.Internal.Base.Functor Data.Yaml.Parser.YamlParser
instance GHC.Internal.Control.Monad.Fail.MonadFail Data.Yaml.Parser.YamlParser
instance GHC.Internal.Base.MonadPlus Data.Yaml.Parser.YamlParser
instance GHC.Internal.Base.Monad Data.Yaml.Parser.YamlParser
instance GHC.Internal.Base.Monoid (Data.Yaml.Parser.YamlParser a)
instance GHC.Internal.Base.Semigroup (Data.Yaml.Parser.YamlParser a)
instance GHC.Internal.Show.Show Data.Yaml.Parser.RawDoc
instance GHC.Internal.Show.Show Data.Yaml.Parser.YamlParseException
instance GHC.Internal.Show.Show Data.Yaml.Parser.YamlValue

-- | Prettier YAML encoding.
module Data.Yaml.Pretty

-- | Configurable encode.
encodePretty :: ToJSON a => Config -> a -> ByteString

data Config

getConfCompare :: Config -> Text -> Text -> Ordering

-- | Sets ordering for object keys
setConfCompare :: (Text -> Text -> Ordering) -> Config -> Config

getConfDropNull :: Config -> Bool

-- | Drop entries with Null value from objects, if set to
--   True
setConfDropNull :: Bool -> Config -> Config

-- | The default configuration: do not sort objects or drop keys
defConfig :: Config
pretty :: Config -> Value -> YamlBuilder

module Data.Yaml.TH

-- | A QuasiQuoter for YAML.
--   
--   
Examples
--   
--   
--   {-# LANGUAGE QuasiQuotes #-}
--   import Data.Yaml.TH
--   
--   value :: Value
--   value = [yamlQQ|
--   name: John Doe
--   age: 23
--   |]
--   
yamlQQ :: QuasiQuoter

-- | Decode a YAML file at compile time. Only available on GHC version
--   7.8.1 or higher.
--   
--   
Examples
--   
--   
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   config :: Config
--   config = $$(decodeFile "config.yaml")
--   
decodeFile :: (Lift a, FromJSON a) => FilePath -> Q (TExp a)

-- | A JSON value represented as a Haskell value.
data Value
Object :: !Object -> Value
Array :: !Array -> Value
String :: !Text -> Value
Number :: !Scientific -> Value
Bool :: !Bool -> Value
Null :: Value

-- | A JSON parser. N.B. This might not fit your usual understanding of
--   "parser". Instead you might like to think of Parser as a "parse
--   result", i.e. a parser to which the input has already been applied.
data Parser a

-- | A JSON "object" (key/value map).
type Object = KeyMap Value

-- | A JSON "array" (sequence).
type Array = Vector Value

-- | Create a Value from a list of name/value Pairs. If
--   duplicate keys arise, later keys and their associated values win.
object :: [Pair] -> Value

-- | Construct a new Value from a list of Values.
array :: [Value] -> Value
(.=) :: (KeyValue e kv, ToJSON v) => Key -> v -> kv
infixr 8 .=

-- | Retrieve the value associated with the given key of an Object.
--   The result is empty if the key is not present or the value
--   cannot be converted to the desired type.
--   
--   This accessor is appropriate if the key and value must be
--   present in an object for it to be valid. If the key and value are
--   optional, use .:? instead.
(.:) :: FromJSON a => Object -> Key -> Parser a

-- | Retrieve the value associated with the given key of an Object.
--   The result is Nothing if the key is not present or if its value
--   is Null, or empty if the value cannot be converted to
--   the desired type.
--   
--   This accessor is most useful if the key and value can be absent from
--   an object without affecting its validity. If the key and value are
--   mandatory, use .: instead.
(.:?) :: FromJSON a => Object -> Key -> Parser (Maybe a)

-- | Helper for use in combination with .:? to provide default
--   values for optional JSON object fields.
--   
--   This combinator is most useful if the key and value can be absent from
--   an object without affecting its validity and we know a default value
--   to assign in that case. If the key and value are mandatory, use
--   .: instead.
--   
--   Example usage:
--   
--   
--   v1 <- o .:? "opt_field_with_dfl" .!= "default_val"
--   v2 <- o .:  "mandatory_field"
--   v3 <- o .:? "opt_field2"
--   
(.!=) :: Parser (Maybe a) -> a -> Parser a

-- | A type that can be converted from JSON, with the possibility of
--   failure.
--   
--   In many cases, you can get the compiler to generate parsing code for
--   you (see below). To begin, let's cover writing an instance by hand.
--   
--   There are various reasons a conversion could fail. For example, an
--   Object could be missing a required key, an Array could
--   be of the wrong size, or a value could be of an incompatible type.
--   
--   The basic ways to signal a failed conversion are as follows:
--   
--   
--   
- fail yields a custom error message: it is the recommended
--   way of reporting a failure;
--   
- empty (or mzero) is uninformative: use it when the
--   error is meant to be caught by some (<|>);
--   
- typeMismatch can be used to report a failure when the
--   encountered value is not of the expected JSON type; unexpected
--   is an appropriate alternative when more than one type may be expected,
--   or to keep the expected type implicit.
--   
--   
--   prependFailure (or modifyFailure) add more information
--   to a parser's error messages.
--   
--   An example type and instance using typeMismatch and
--   prependFailure:
--   
--   
--   -- Allow ourselves to write Text literals.
--   {-# LANGUAGE OverloadedStrings #-}
--   
--   data Coord = Coord { x :: Double, y :: Double }
--   
--   instance FromJSON Coord where
--       parseJSON (Object v) = Coord
--           <$> v .: "x"
--           <*> v .: "y"
--   
--       -- We do not expect a non-Object value here.
--       -- We could use empty to fail, but typeMismatch
--       -- gives a much more informative error message.
--       parseJSON invalid    =
--           prependFailure "parsing Coord failed, "
--               (typeMismatch "Object" invalid)
--   
--   
--   For this common case of only being concerned with a single type of
--   JSON value, the functions withObject, withScientific,
--   etc. are provided. Their use is to be preferred when possible, since
--   they are more terse. Using withObject, we can rewrite the above
--   instance (assuming the same language extension and data type) as:
--   
--   
--   instance FromJSON Coord where
--       parseJSON = withObject "Coord" $ \v -> Coord
--           <$> v .: "x"
--           <*> v .: "y"
--   
--   
--   Instead of manually writing your FromJSON instance, there are
--   two options to do it automatically:
--   
--   
--   
- Data.Aeson.TH provides Template Haskell functions which
--   will derive an instance at compile time. The generated instance is
--   optimized for your type so it will probably be more efficient than the
--   following option.
--   
- The compiler can provide a default generic implementation for
--   parseJSON.
--   
--   
--   To use the second, simply add a deriving Generic
--   clause to your datatype and declare a FromJSON instance for
--   your datatype without giving a definition for parseJSON.
--   
--   For example, the previous example can be simplified to just:
--   
--   
--   {-# LANGUAGE DeriveGeneric #-}
--   
--   import GHC.Generics
--   
--   data Coord = Coord { x :: Double, y :: Double } deriving Generic
--   
--   instance FromJSON Coord
--   
--   
--   or using the DerivingVia extension
--   
--   
--   deriving via Generically Coord instance FromJSON Coord
--   
--   
--   The default implementation will be equivalent to parseJSON =
--   genericParseJSON defaultOptions; if you need
--   different options, you can customize the generic decoding by defining:
--   
--   
--   customOptions = defaultOptions
--                   { fieldLabelModifier = map toUpper
--                   }
--   
--   instance FromJSON Coord where
--       parseJSON = genericParseJSON customOptions
--   
class FromJSON a
parseJSON :: FromJSON a => Value -> Parser a
($dmparseJSON) :: (FromJSON a, Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a
parseJSONList :: FromJSON a => Value -> Parser [a]

-- | Default value for optional fields. Used by (.:?=)
--   operator, and Generics and TH deriving with
--   allowOmittedFields = True (default).
omittedField :: FromJSON a => Maybe a
