Data.Yaml

yaml-0.8.18.1: Support for parsing and rendering YAML documents.

Safe Haskell | None
Language | Haskell98

Data.Yaml

Contents

- Types
- Constructors and accessors
- Parsing
- Classes
- Encoding/decoding
  - Better error information
  - More control over decoding

Description

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.

Synopsis

- data Value :: *
  - = Object ~Object
  - | Array ~Array
  - | String ~Text
  - | Number ~Scientific
  - | Bool ~Bool
  - | Null
- data Parser a :: * -> *
- type Object = HashMap Text Value
- type Array = Vector Value
- data ParseException
  - = NonScalarKey
  - | UnknownAlias {
    - _anchorName :: AnchorName
    }
  - | UnexpectedEvent {
    - _received :: Maybe Event
    - _expected :: Maybe Event
    }
  - | InvalidYaml (Maybe YamlException)
  - | AesonException String
  - | OtherParseException SomeException
  - | NonStringKeyAlias AnchorName Value
  - | CyclicIncludes
- prettyPrintParseException :: ParseException -> String
- data YamlException
  - = YamlException String
  - | YamlParseException {
    - yamlProblem :: String
    - yamlContext :: String
    - yamlProblemMark :: YamlMark
    }
- data YamlMark = YamlMark {
  - yamlIndex :: Int
  - yamlLine :: Int
  - yamlColumn :: Int
  }
- object :: [Pair] -> Value
- array :: [Value] -> Value
- (.=) :: KeyValue kv => forall v. ToJSON v => Text -> v -> kv
- (.:) :: FromJSON a => Object -> Text -> Parser a
- (.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)
- (.!=) :: Parser (Maybe a) -> a -> Parser a
- parseMonad :: Monad m => (a -> Parser b) -> a -> m b
- parseEither :: (a -> Parser b) -> a -> Either String b
- parseMaybe :: (a -> Parser b) -> a -> Maybe b
- class ToJSON a where
  - toJSON :: a -> Value
  - toEncoding :: a -> Encoding
- class FromJSON a where
  - parseJSON :: Value -> Parser a
- encode :: ToJSON a => a -> ByteString
- encodeFile :: ToJSON a => FilePath -> a -> IO ()
- decode :: FromJSON a => ByteString -> Maybe a
- decodeFile :: FromJSON a => FilePath -> IO (Maybe a)
- decodeEither :: FromJSON a => ByteString -> Either String a
- decodeEither' :: FromJSON a => ByteString -> Either ParseException a
- decodeFileEither :: FromJSON a => FilePath -> IO (Either ParseException a)
- decodeHelper :: FromJSON a => Source Parse Event -> IO (Either ParseException (Either String a))

# Types

data Value :: * #

A JSON value represented as a Haskell value.

Constructors

Object ~Object |
Array ~Array |
String ~Text |
Number ~Scientific |
Bool ~Bool |
Null |

Instances

Eq Value |
Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Data Value |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Value -> c Value # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Value # toConstr :: Value -> Constr # dataTypeOf :: Value -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Value) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value) # gmapT :: (forall b. Data b => b -> b) -> Value -> Value # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQ :: (forall d. Data d => d -> u) -> Value -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #
Read Value |
Methods readsPrec :: Int -> ReadS Value # readList :: ReadS [Value] # readPrec :: ReadPrec Value # readListPrec :: ReadPrec [Value] #
Show Value |
Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
IsString Value |
Methods fromString :: String -> Value #
Lift Value |
Methods lift :: Value -> Q Exp #
NFData Value |
Methods rnf :: Value -> () #
Hashable Value |
Methods hashWithSalt :: Int -> Value -> Int # hash :: Value -> Int #

data Parser a :: * -> * #

A JSON parser.

Instances

Monad Parser |
Methods (>>=) :: Parser a -> (a -> Parser b) -> Parser b # (>>) :: Parser a -> Parser b -> Parser b # return :: a -> Parser a # fail :: String -> Parser a #
Functor Parser |
Methods fmap :: (a -> b) -> Parser a -> Parser b # (<$) :: a -> Parser b -> Parser a #
MonadFail Parser |
Methods fail :: String -> Parser a #
Applicative Parser |
Methods pure :: a -> Parser a # (<*>) :: Parser (a -> b) -> Parser a -> Parser b # (*>) :: Parser a -> Parser b -> Parser b # (<*) :: Parser a -> Parser b -> Parser a #
Alternative Parser |
Methods empty :: Parser a # (<|>) :: Parser a -> Parser a -> Parser a # some :: Parser a -> Parser [a] # many :: Parser a -> Parser [a] #
MonadPlus Parser |
Methods mzero :: Parser a # mplus :: Parser a -> Parser a -> Parser a #
Semigroup (Parser a) |
Methods (<>) :: Parser a -> Parser a -> Parser a # sconcat :: NonEmpty (Parser a) -> Parser a # stimes :: Integral b => b -> Parser a -> Parser a #
Monoid (Parser a) |
Methods mempty :: Parser a # mappend :: Parser a -> Parser a -> Parser a # mconcat :: [Parser a] -> Parser a #

type Object = HashMap Text Value #

A JSON "object" (key/value map).

type Array = Vector Value #

A JSON "array" (sequence).

data ParseException #

Constructors

NonScalarKey |
UnknownAlias |
Fields _anchorName :: AnchorName
UnexpectedEvent |
Fields _received :: Maybe Event _expected :: Maybe Event
InvalidYaml (Maybe YamlException) |
AesonException String |
OtherParseException SomeException |
NonStringKeyAlias AnchorName Value |
CyclicIncludes |

Instances

Show ParseException # |
Methods showsPrec :: Int -> ParseException -> ShowS # show :: ParseException -> String # showList :: [ParseException] -> ShowS #
Exception ParseException # |
Methods toException :: ParseException -> SomeException # fromException :: SomeException -> Maybe ParseException # displayException :: ParseException -> String #

prettyPrintParseException :: ParseException -> String #

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

data YamlException #

Constructors

YamlException String |
YamlParseException | problem, context, index, position line, position column
Fields yamlProblem :: String yamlContext :: String yamlProblemMark :: YamlMark

Instances

Show YamlException # |
Methods showsPrec :: Int -> YamlException -> ShowS # show :: YamlException -> String # showList :: [YamlException] -> ShowS #
Exception YamlException # |
Methods toException :: YamlException -> SomeException # fromException :: SomeException -> Maybe YamlException # displayException :: YamlException -> String #

data YamlMark #

The pointer position

Constructors

YamlMark |
Fields yamlIndex :: Int yamlLine :: Int yamlColumn :: Int

Instances

Show YamlMark # |
Methods showsPrec :: Int -> YamlMark -> ShowS # show :: YamlMark -> String # showList :: [YamlMark] -> ShowS #

# Constructors and accessors

object :: [Pair] -> Value #

Create a `Value` from a list of name/value `Pair`s. If duplicate keys arise, earlier keys and their associated values win.

array :: [Value] -> Value #

(.=) :: KeyValue kv => forall v. ToJSON v => Text -> v -> kv #

(.:) :: FromJSON a => Object -> Text -> Parser a #

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 -> Text -> Parser (Maybe a) #

Retrieve the value associated with the given key of an `Object`. The result is `Nothing` if the key is not present, 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.

(.!=) :: Parser (Maybe a) -> a -> Parser 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"

# Parsing

parseMonad :: Monad m => (a -> Parser b) -> a -> m b #

parseEither :: (a -> Parser b) -> a -> Either String b #

Run a `Parser` with an `Either` result type. If the parse fails, the `Left` payload will contain an error message.

parseMaybe :: (a -> Parser b) -> a -> Maybe b #

Run a `Parser` with a `Maybe` result type.

# Classes

class ToJSON a where #

A type that can be converted to JSON.

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 will probably be more efficient than the following two options:
- 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 for your datatype without giving definitions for `toJSON` or `toEncoding`.

For example, the previous example can be simplified to a more minimal instance:

    {-# LANGUAGE DeriveGeneric #-}

    import GHC.Generics

    data Coord = Coord { x :: Double, y :: Double } deriving Generic

    instance ToJSON Coord where
        toEncoding = genericToEncoding defaultOptions

Why do we provide an implementation for `toEncoding` here? The `toEncoding` function is a relatively new addition to this class. To allow users of older versions of this library to upgrade without having to edit all of their instances or encounter surprising incompatibilities, the default implementation of `toEncoding` uses `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`. Our one-liner definition of `toEncoding` above bypasses the intermediate `Value`.

If `DefaultSignatures` doesn't give exactly the results you want, you can customize the generic encoding with only a tiny amount of effort, using `genericToJSON` and `genericToEncoding` with your preferred `Options`:

    instance ToJSON Coord where
        toJSON     = genericToJSON defaultOptions
        toEncoding = genericToEncoding defaultOptions

Minimal complete definition

Nothing

class FromJSON a where #

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:

- `empty` and `mzero` work, but are terse and uninformative
- `fail` yields a custom error message
- `typeMismatch` produces an informative message for cases when the value encountered is not of the expected type

An example type and instance:

    -- 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 mzero to fail, but typeMismatch
      -- gives a much more informative error message.
      parseJSON invalid    = typeMismatch "Coord" invalid

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 will probably be more efficient than the following two options:
- 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

If `DefaultSignatures` doesn't give exactly the results you want, you can customize the generic decoding with only a tiny amount of effort, using `genericParseJSON` with your preferred `Options`:

    instance FromJSON Coord where
        parseJSON = genericParseJSON defaultOptions

Minimal complete definition

Nothing

# Encoding/decoding

encode :: ToJSON a => a -> ByteString #

encodeFile :: ToJSON a => FilePath -> a -> IO () #

decode :: FromJSON a => ByteString -> Maybe a #

decodeFile :: FromJSON a => FilePath -> IO (Maybe a) #

## Better error information

decodeEither :: FromJSON a => ByteString -> Either String a #

decodeEither' :: FromJSON a => ByteString -> Either ParseException a #

More helpful version of `decodeEither` which returns the `YamlException`.

Since 0.8.3

decodeFileEither :: FromJSON a => FilePath -> IO (Either ParseException a) #

A version of `decodeFile` which should not throw runtime exceptions.

Since 0.8.4

## More control over decoding

decodeHelper :: FromJSON a => Source Parse Event -> IO (Either ParseException (Either String a)) #