yaml-0.8.22: 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
  - toJSONList :: [a] -> Value
  - toEncodingList :: [a] -> Encoding
- class FromJSON a where
  - parseJSON :: Value -> Parser a
  - parseJSONList :: 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 #
Hashable Value |
Methods hashWithSalt :: Int -> Value -> Int # hash :: Value -> Int #
FromJSON Value |
Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] #
ToJSON Value |
Methods toJSON :: Value -> Value # toEncoding :: Value -> Encoding # toJSONList :: [Value] -> Value # toEncodingList :: [Value] -> Encoding #
KeyValue Pair |
Methods (.=) :: ToJSON v => Text -> v -> Pair #
NFData Value |
Methods rnf :: Value -> () #

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 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.

(.!=) :: 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

Instances

ToJSON Bool |
Methods toJSON :: Bool -> Value # toEncoding :: Bool -> Encoding # toJSONList :: [Bool] -> Value # toEncodingList :: [Bool] -> Encoding #
ToJSON Char |
Methods toJSON :: Char -> Value # toEncoding :: Char -> Encoding # toJSONList :: [Char] -> Value # toEncodingList :: [Char] -> Encoding #
ToJSON Double |
Methods toJSON :: Double -> Value # toEncoding :: Double -> Encoding # toJSONList :: [Double] -> Value # toEncodingList :: [Double] -> Encoding #
ToJSON Float |
Methods toJSON :: Float -> Value # toEncoding :: Float -> Encoding # toJSONList :: [Float] -> Value # toEncodingList :: [Float] -> Encoding #
ToJSON Int |
Methods toJSON :: Int -> Value # toEncoding :: Int -> Encoding # toJSONList :: [Int] -> Value # toEncodingList :: [Int] -> Encoding #
ToJSON Int8 |
Methods toJSON :: Int8 -> Value # toEncoding :: Int8 -> Encoding # toJSONList :: [Int8] -> Value # toEncodingList :: [Int8] -> Encoding #
ToJSON Int16 |
Methods toJSON :: Int16 -> Value # toEncoding :: Int16 -> Encoding # toJSONList :: [Int16] -> Value # toEncodingList :: [Int16] -> Encoding #
ToJSON Int32 |
Methods toJSON :: Int32 -> Value # toEncoding :: Int32 -> Encoding # toJSONList :: [Int32] -> Value # toEncodingList :: [Int32] -> Encoding #
ToJSON Int64 |
Methods toJSON :: Int64 -> Value # toEncoding :: Int64 -> Encoding # toJSONList :: [Int64] -> Value # toEncodingList :: [Int64] -> Encoding #
ToJSON Integer |
Methods toJSON :: Integer -> Value # toEncoding :: Integer -> Encoding # toJSONList :: [Integer] -> Value # toEncodingList :: [Integer] -> Encoding #
ToJSON Ordering |
Methods toJSON :: Ordering -> Value # toEncoding :: Ordering -> Encoding # toJSONList :: [Ordering] -> Value # toEncodingList :: [Ordering] -> Encoding #
ToJSON Word |
Methods toJSON :: Word -> Value # toEncoding :: Word -> Encoding # toJSONList :: [Word] -> Value # toEncodingList :: [Word] -> Encoding #
ToJSON Word8 |
Methods toJSON :: Word8 -> Value # toEncoding :: Word8 -> Encoding # toJSONList :: [Word8] -> Value # toEncodingList :: [Word8] -> Encoding #
ToJSON Word16 |
Methods toJSON :: Word16 -> Value # toEncoding :: Word16 -> Encoding # toJSONList :: [Word16] -> Value # toEncodingList :: [Word16] -> Encoding #
ToJSON Word32 |
Methods toJSON :: Word32 -> Value # toEncoding :: Word32 -> Encoding # toJSONList :: [Word32] -> Value # toEncodingList :: [Word32] -> Encoding #
ToJSON Word64 |
Methods toJSON :: Word64 -> Value # toEncoding :: Word64 -> Encoding # toJSONList :: [Word64] -> Value # toEncodingList :: [Word64] -> Encoding #
ToJSON () |
Methods toJSON :: () -> Value # toEncoding :: () -> Encoding # toJSONList :: [()] -> Value # toEncodingList :: [()] -> Encoding #
ToJSON Scientific |
Methods toJSON :: Scientific -> Value # toEncoding :: Scientific -> Encoding # toJSONList :: [Scientific] -> Value # toEncodingList :: [Scientific] -> Encoding #
ToJSON Number |
Methods toJSON :: Number -> Value # toEncoding :: Number -> Encoding # toJSONList :: [Number] -> Value # toEncodingList :: [Number] -> Encoding #
ToJSON Text |
Methods toJSON :: Text -> Value # toEncoding :: Text -> Encoding # toJSONList :: [Text] -> Value # toEncodingList :: [Text] -> Encoding #
ToJSON UTCTime |
Methods toJSON :: UTCTime -> Value # toEncoding :: UTCTime -> Encoding # toJSONList :: [UTCTime] -> Value # toEncodingList :: [UTCTime] -> Encoding #
ToJSON Value |
Methods toJSON :: Value -> Value # toEncoding :: Value -> Encoding # toJSONList :: [Value] -> Value # toEncodingList :: [Value] -> Encoding #
ToJSON DotNetTime |
Methods toJSON :: DotNetTime -> Value # toEncoding :: DotNetTime -> Encoding # toJSONList :: [DotNetTime] -> Value # toEncodingList :: [DotNetTime] -> Encoding #
ToJSON Text |
Methods toJSON :: Text -> Value # toEncoding :: Text -> Encoding # toJSONList :: [Text] -> Value # toEncodingList :: [Text] -> Encoding #
ToJSON Natural |
Methods toJSON :: Natural -> Value # toEncoding :: Natural -> Encoding # toJSONList :: [Natural] -> Value # toEncodingList :: [Natural] -> Encoding #
ToJSON Version |
Methods toJSON :: Version -> Value # toEncoding :: Version -> Encoding # toJSONList :: [Version] -> Value # toEncodingList :: [Version] -> Encoding #
ToJSON IntSet |
Methods toJSON :: IntSet -> Value # toEncoding :: IntSet -> Encoding # toJSONList :: [IntSet] -> Value # toEncodingList :: [IntSet] -> Encoding #
ToJSON LocalTime |
Methods toJSON :: LocalTime -> Value # toEncoding :: LocalTime -> Encoding # toJSONList :: [LocalTime] -> Value # toEncodingList :: [LocalTime] -> Encoding #
ToJSON ZonedTime |
Methods toJSON :: ZonedTime -> Value # toEncoding :: ZonedTime -> Encoding # toJSONList :: [ZonedTime] -> Value # toEncodingList :: [ZonedTime] -> Encoding #
ToJSON TimeOfDay |
Methods toJSON :: TimeOfDay -> Value # toEncoding :: TimeOfDay -> Encoding # toJSONList :: [TimeOfDay] -> Value # toEncodingList :: [TimeOfDay] -> Encoding #
ToJSON NominalDiffTime |
Methods toJSON :: NominalDiffTime -> Value # toEncoding :: NominalDiffTime -> Encoding # toJSONList :: [NominalDiffTime] -> Value # toEncodingList :: [NominalDiffTime] -> Encoding #
ToJSON Day |
Methods toJSON :: Day -> Value # toEncoding :: Day -> Encoding # toJSONList :: [Day] -> Value # toEncodingList :: [Day] -> Encoding #
ToJSON a => ToJSON [a] |
Methods toJSON :: [a] -> Value # toEncoding :: [a] -> Encoding # toJSONList :: [[a]] -> Value # toEncodingList :: [[a]] -> Encoding #
ToJSON a => ToJSON (Maybe a) |
Methods toJSON :: Maybe a -> Value # toEncoding :: Maybe a -> Encoding # toJSONList :: [Maybe a] -> Value # toEncodingList :: [Maybe a] -> Encoding #
(ToJSON a, Integral a) => ToJSON (Ratio a) |
Methods toJSON :: Ratio a -> Value # toEncoding :: Ratio a -> Encoding # toJSONList :: [Ratio a] -> Value # toEncodingList :: [Ratio a] -> Encoding #
ToJSON a => ToJSON (Identity a) |
Methods toJSON :: Identity a -> Value # toEncoding :: Identity a -> Encoding # toJSONList :: [Identity a] -> Value # toEncodingList :: [Identity a] -> Encoding #
ToJSON a => ToJSON (Min a) |
Methods toJSON :: Min a -> Value # toEncoding :: Min a -> Encoding # toJSONList :: [Min a] -> Value # toEncodingList :: [Min a] -> Encoding #
ToJSON a => ToJSON (Max a) |
Methods toJSON :: Max a -> Value # toEncoding :: Max a -> Encoding # toJSONList :: [Max a] -> Value # toEncodingList :: [Max a] -> Encoding #
ToJSON a => ToJSON (First a) |
Methods toJSON :: First a -> Value # toEncoding :: First a -> Encoding # toJSONList :: [First a] -> Value # toEncodingList :: [First a] -> Encoding #
ToJSON a => ToJSON (Last a) |
Methods toJSON :: Last a -> Value # toEncoding :: Last a -> Encoding # toJSONList :: [Last a] -> Value # toEncodingList :: [Last a] -> Encoding #
ToJSON a => ToJSON (WrappedMonoid a) |
Methods toJSON :: WrappedMonoid a -> Value # toEncoding :: WrappedMonoid a -> Encoding # toJSONList :: [WrappedMonoid a] -> Value # toEncodingList :: [WrappedMonoid a] -> Encoding #
ToJSON a => ToJSON (Option a) |
Methods toJSON :: Option a -> Value # toEncoding :: Option a -> Encoding # toJSONList :: [Option a] -> Value # toEncodingList :: [Option a] -> Encoding #
ToJSON a => ToJSON (NonEmpty a) |
Methods toJSON :: NonEmpty a -> Value # toEncoding :: NonEmpty a -> Encoding # toJSONList :: [NonEmpty a] -> Value # toEncodingList :: [NonEmpty a] -> Encoding #
HasResolution a => ToJSON (Fixed a) |
Methods toJSON :: Fixed a -> Value # toEncoding :: Fixed a -> Encoding # toJSONList :: [Fixed a] -> Value # toEncodingList :: [Fixed a] -> Encoding #
ToJSON a => ToJSON (Dual a) |
Methods toJSON :: Dual a -> Value # toEncoding :: Dual a -> Encoding # toJSONList :: [Dual a] -> Value # toEncodingList :: [Dual a] -> Encoding #
ToJSON a => ToJSON (First a) |
Methods toJSON :: First a -> Value # toEncoding :: First a -> Encoding # toJSONList :: [First a] -> Value # toEncodingList :: [First a] -> Encoding #
ToJSON a => ToJSON (Last a) |
Methods toJSON :: Last a -> Value # toEncoding :: Last a -> Encoding # toJSONList :: [Last a] -> Value # toEncodingList :: [Last a] -> Encoding #
ToJSON v => ToJSON (Tree v) |
Methods toJSON :: Tree v -> Value # toEncoding :: Tree v -> Encoding # toJSONList :: [Tree v] -> Value # toEncodingList :: [Tree v] -> Encoding #
ToJSON a => ToJSON (Seq a) |
Methods toJSON :: Seq a -> Value # toEncoding :: Seq a -> Encoding # toJSONList :: [Seq a] -> Value # toEncodingList :: [Seq a] -> Encoding #
ToJSON a => ToJSON (IntMap a) |
Methods toJSON :: IntMap a -> Value # toEncoding :: IntMap a -> Encoding # toJSONList :: [IntMap a] -> Value # toEncodingList :: [IntMap a] -> Encoding #
ToJSON a => ToJSON (Set a) |
Methods toJSON :: Set a -> Value # toEncoding :: Set a -> Encoding # toJSONList :: [Set a] -> Value # toEncodingList :: [Set a] -> Encoding #
ToJSON a => ToJSON (DList a) |
Methods toJSON :: DList a -> Value # toEncoding :: DList a -> Encoding # toJSONList :: [DList a] -> Value # toEncodingList :: [DList a] -> Encoding #
ToJSON a => ToJSON (HashSet a) |
Methods toJSON :: HashSet a -> Value # toEncoding :: HashSet a -> Encoding # toJSONList :: [HashSet a] -> Value # toEncodingList :: [HashSet a] -> Encoding #
ToJSON a => ToJSON (Vector a) |
Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
(Vector Vector a, ToJSON a) => ToJSON (Vector a) |
Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
(Storable a, ToJSON a) => ToJSON (Vector a) |
Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
(Prim a, ToJSON a) => ToJSON (Vector a) |
Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
(ToJSON a, ToJSON b) => ToJSON (Either a b) |
Methods toJSON :: Either a b -> Value # toEncoding :: Either a b -> Encoding # toJSONList :: [Either a b] -> Value # toEncodingList :: [Either a b] -> Encoding #
(ToJSON a, ToJSON b) => ToJSON (a, b) |
Methods toJSON :: (a, b) -> Value # toEncoding :: (a, b) -> Encoding # toJSONList :: [(a, b)] -> Value # toEncodingList :: [(a, b)] -> Encoding #
(ToJSON v, ToJSONKey k) => ToJSON (HashMap k v) |
Methods toJSON :: HashMap k v -> Value # toEncoding :: HashMap k v -> Encoding # toJSONList :: [HashMap k v] -> Value # toEncodingList :: [HashMap k v] -> Encoding #
(ToJSON v, ToJSONKey k) => ToJSON (Map k v) |
Methods toJSON :: Map k v -> Value # toEncoding :: Map k v -> Encoding # toJSONList :: [Map k v] -> Value # toEncodingList :: [Map k v] -> Encoding #
ToJSON (Proxy k a) |
Methods toJSON :: Proxy k a -> Value # toEncoding :: Proxy k a -> Encoding # toJSONList :: [Proxy k a] -> Value # toEncodingList :: [Proxy k a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c) => ToJSON (a, b, c) |
Methods toJSON :: (a, b, c) -> Value # toEncoding :: (a, b, c) -> Encoding # toJSONList :: [(a, b, c)] -> Value # toEncodingList :: [(a, b, c)] -> Encoding #
ToJSON a => ToJSON (Const k a b) |
Methods toJSON :: Const k a b -> Value # toEncoding :: Const k a b -> Encoding # toJSONList :: [Const k a b] -> Value # toEncodingList :: [Const k a b] -> Encoding #
ToJSON b => ToJSON (Tagged k a b) |
Methods toJSON :: Tagged k a b -> Value # toEncoding :: Tagged k a b -> Encoding # toJSONList :: [Tagged k a b] -> Value # toEncodingList :: [Tagged k a b] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON (a, b, c, d) |
Methods toJSON :: (a, b, c, d) -> Value # toEncoding :: (a, b, c, d) -> Encoding # toJSONList :: [(a, b, c, d)] -> Value # toEncodingList :: [(a, b, c, d)] -> Encoding #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Sum * f g a) |
Methods toJSON :: Sum * f g a -> Value # toEncoding :: Sum * f g a -> Encoding # toJSONList :: [Sum * f g a] -> Value # toEncodingList :: [Sum * f g a] -> Encoding #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Product * f g a) |
Methods toJSON :: Product * f g a -> Value # toEncoding :: Product * f g a -> Encoding # toJSONList :: [Product * f g a] -> Value # toEncodingList :: [Product * f g a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON (a, b, c, d, e) |
Methods toJSON :: (a, b, c, d, e) -> Value # toEncoding :: (a, b, c, d, e) -> Encoding # toJSONList :: [(a, b, c, d, e)] -> Value # toEncodingList :: [(a, b, c, d, e)] -> Encoding #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Compose * * f g a) |
Methods toJSON :: Compose * * f g a -> Value # toEncoding :: Compose * * f g a -> Encoding # toJSONList :: [Compose * * f g a] -> Value # toEncodingList :: [Compose * * f g a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON (a, b, c, d, e, f) |
Methods toJSON :: (a, b, c, d, e, f) -> Value # toEncoding :: (a, b, c, d, e, f) -> Encoding # toJSONList :: [(a, b, c, d, e, f)] -> Value # toEncodingList :: [(a, b, c, d, e, f)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON (a, b, c, d, e, f, g) |
Methods toJSON :: (a, b, c, d, e, f, g) -> Value # toEncoding :: (a, b, c, d, e, f, g) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON (a, b, c, d, e, f, g, h) |
Methods toJSON :: (a, b, c, d, e, f, g, h) -> Value # toEncoding :: (a, b, c, d, e, f, g, h) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON (a, b, c, d, e, f, g, h, i) |
Methods toJSON :: (a, b, c, d, e, f, g, h, i) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON (a, b, c, d, e, f, g, h, i, j) |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON (a, b, c, d, e, f, g, h, i, j, k) |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l) |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m) |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n, ToJSON o) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Encoding #

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

Instances

FromJSON Bool |
Methods parseJSON :: Value -> Parser Bool # parseJSONList :: Value -> Parser [Bool] #
FromJSON Char |
Methods parseJSON :: Value -> Parser Char # parseJSONList :: Value -> Parser [Char] #
FromJSON Double |
Methods parseJSON :: Value -> Parser Double # parseJSONList :: Value -> Parser [Double] #
FromJSON Float |
Methods parseJSON :: Value -> Parser Float # parseJSONList :: Value -> Parser [Float] #
FromJSON Int |
Methods parseJSON :: Value -> Parser Int # parseJSONList :: Value -> Parser [Int] #
FromJSON Int8 |
Methods parseJSON :: Value -> Parser Int8 # parseJSONList :: Value -> Parser [Int8] #
FromJSON Int16 |
Methods parseJSON :: Value -> Parser Int16 # parseJSONList :: Value -> Parser [Int16] #
FromJSON Int32 |
Methods parseJSON :: Value -> Parser Int32 # parseJSONList :: Value -> Parser [Int32] #
FromJSON Int64 |
Methods parseJSON :: Value -> Parser Int64 # parseJSONList :: Value -> Parser [Int64] #
FromJSON Integer | WARNING: Only parse Integers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like `1e1000000000`.
Methods parseJSON :: Value -> Parser Integer # parseJSONList :: Value -> Parser [Integer] #
FromJSON Ordering |
Methods parseJSON :: Value -> Parser Ordering # parseJSONList :: Value -> Parser [Ordering] #
FromJSON Word |
Methods parseJSON :: Value -> Parser Word # parseJSONList :: Value -> Parser [Word] #
FromJSON Word8 |
Methods parseJSON :: Value -> Parser Word8 # parseJSONList :: Value -> Parser [Word8] #
FromJSON Word16 |
Methods parseJSON :: Value -> Parser Word16 # parseJSONList :: Value -> Parser [Word16] #
FromJSON Word32 |
Methods parseJSON :: Value -> Parser Word32 # parseJSONList :: Value -> Parser [Word32] #
FromJSON Word64 |
Methods parseJSON :: Value -> Parser Word64 # parseJSONList :: Value -> Parser [Word64] #
FromJSON () |
Methods parseJSON :: Value -> Parser () # parseJSONList :: Value -> Parser [()] #
FromJSON Scientific |
Methods parseJSON :: Value -> Parser Scientific # parseJSONList :: Value -> Parser [Scientific] #
FromJSON Number |
Methods parseJSON :: Value -> Parser Number # parseJSONList :: Value -> Parser [Number] #
FromJSON Text |
Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSON UTCTime |
Methods parseJSON :: Value -> Parser UTCTime # parseJSONList :: Value -> Parser [UTCTime] #
FromJSON Value |
Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] #
FromJSON DotNetTime |
Methods parseJSON :: Value -> Parser DotNetTime # parseJSONList :: Value -> Parser [DotNetTime] #
FromJSON Text |
Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSON Natural |
Methods parseJSON :: Value -> Parser Natural # parseJSONList :: Value -> Parser [Natural] #
FromJSON Version |
Methods parseJSON :: Value -> Parser Version # parseJSONList :: Value -> Parser [Version] #
FromJSON IntSet |
Methods parseJSON :: Value -> Parser IntSet # parseJSONList :: Value -> Parser [IntSet] #
FromJSON LocalTime |
Methods parseJSON :: Value -> Parser LocalTime # parseJSONList :: Value -> Parser [LocalTime] #
FromJSON ZonedTime |
Methods parseJSON :: Value -> Parser ZonedTime # parseJSONList :: Value -> Parser [ZonedTime] #
FromJSON TimeOfDay |
Methods parseJSON :: Value -> Parser TimeOfDay # parseJSONList :: Value -> Parser [TimeOfDay] #
FromJSON NominalDiffTime | WARNING: Only parse lengths of time from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like `1e1000000000`.
Methods parseJSON :: Value -> Parser NominalDiffTime # parseJSONList :: Value -> Parser [NominalDiffTime] #
FromJSON Day |
Methods parseJSON :: Value -> Parser Day # parseJSONList :: Value -> Parser [Day] #
FromJSON a => FromJSON [a] |
Methods parseJSON :: Value -> Parser [a] # parseJSONList :: Value -> Parser [[a]] #
FromJSON a => FromJSON (Maybe a) |
Methods parseJSON :: Value -> Parser (Maybe a) # parseJSONList :: Value -> Parser [Maybe a] #
(FromJSON a, Integral a) => FromJSON (Ratio a) |
Methods parseJSON :: Value -> Parser (Ratio a) # parseJSONList :: Value -> Parser [Ratio a] #
FromJSON a => FromJSON (Identity a) |
Methods parseJSON :: Value -> Parser (Identity a) # parseJSONList :: Value -> Parser [Identity a] #
FromJSON a => FromJSON (Min a) |
Methods parseJSON :: Value -> Parser (Min a) # parseJSONList :: Value -> Parser [Min a] #
FromJSON a => FromJSON (Max a) |
Methods parseJSON :: Value -> Parser (Max a) # parseJSONList :: Value -> Parser [Max a] #
FromJSON a => FromJSON (First a) |
Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] #
FromJSON a => FromJSON (Last a) |
Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] #
FromJSON a => FromJSON (WrappedMonoid a) |
Methods parseJSON :: Value -> Parser (WrappedMonoid a) # parseJSONList :: Value -> Parser [WrappedMonoid a] #
FromJSON a => FromJSON (Option a) |
Methods parseJSON :: Value -> Parser (Option a) # parseJSONList :: Value -> Parser [Option a] #
FromJSON a => FromJSON (NonEmpty a) |
Methods parseJSON :: Value -> Parser (NonEmpty a) # parseJSONList :: Value -> Parser [NonEmpty a] #
HasResolution a => FromJSON (Fixed a) | WARNING: Only parse fixed-precision numbers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like `1e1000000000`.
Methods parseJSON :: Value -> Parser (Fixed a) # parseJSONList :: Value -> Parser [Fixed a] #
FromJSON a => FromJSON (Dual a) |
Methods parseJSON :: Value -> Parser (Dual a) # parseJSONList :: Value -> Parser [Dual a] #
FromJSON a => FromJSON (First a) |
Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] #
FromJSON a => FromJSON (Last a) |
Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] #
FromJSON v => FromJSON (Tree v) |
Methods parseJSON :: Value -> Parser (Tree v) # parseJSONList :: Value -> Parser [Tree v] #
FromJSON a => FromJSON (Seq a) |
Methods parseJSON :: Value -> Parser (Seq a) # parseJSONList :: Value -> Parser [Seq a] #
FromJSON a => FromJSON (IntMap a) |
Methods parseJSON :: Value -> Parser (IntMap a) # parseJSONList :: Value -> Parser [IntMap a] #
(Ord a, FromJSON a) => FromJSON (Set a) |
Methods parseJSON :: Value -> Parser (Set a) # parseJSONList :: Value -> Parser [Set a] #
FromJSON a => FromJSON (DList a) |
Methods parseJSON :: Value -> Parser (DList a) # parseJSONList :: Value -> Parser [DList a] #
(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a) |
Methods parseJSON :: Value -> Parser (HashSet a) # parseJSONList :: Value -> Parser [HashSet a] #
FromJSON a => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Vector Vector a, FromJSON a) => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Storable a, FromJSON a) => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Prim a, FromJSON a) => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(FromJSON a, FromJSON b) => FromJSON (Either a b) |
Methods parseJSON :: Value -> Parser (Either a b) # parseJSONList :: Value -> Parser [Either a b] #
(FromJSON a, FromJSON b) => FromJSON (a, b) |
Methods parseJSON :: Value -> Parser (a, b) # parseJSONList :: Value -> Parser [(a, b)] #
(FromJSON v, FromJSONKey k, Eq k, Hashable k) => FromJSON (HashMap k v) |
Methods parseJSON :: Value -> Parser (HashMap k v) # parseJSONList :: Value -> Parser [HashMap k v] #
(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) |
Methods parseJSON :: Value -> Parser (Map k v) # parseJSONList :: Value -> Parser [Map k v] #
FromJSON (Proxy k a) |
Methods parseJSON :: Value -> Parser (Proxy k a) # parseJSONList :: Value -> Parser [Proxy k a] #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c) |
Methods parseJSON :: Value -> Parser (a, b, c) # parseJSONList :: Value -> Parser [(a, b, c)] #
FromJSON a => FromJSON (Const k a b) |
Methods parseJSON :: Value -> Parser (Const k a b) # parseJSONList :: Value -> Parser [Const k a b] #
FromJSON b => FromJSON (Tagged k a b) |
Methods parseJSON :: Value -> Parser (Tagged k a b) # parseJSONList :: Value -> Parser [Tagged k a b] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d) |
Methods parseJSON :: Value -> Parser (a, b, c, d) # parseJSONList :: Value -> Parser [(a, b, c, d)] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum * f g a) |
Methods parseJSON :: Value -> Parser (Sum * f g a) # parseJSONList :: Value -> Parser [Sum * f g a] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Product * f g a) |
Methods parseJSON :: Value -> Parser (Product * f g a) # parseJSONList :: Value -> Parser [Product * f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON (a, b, c, d, e) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e) # parseJSONList :: Value -> Parser [(a, b, c, d, e)] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Compose * * f g a) |
Methods parseJSON :: Value -> Parser (Compose * * f g a) # parseJSONList :: Value -> Parser [Compose * * f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON (a, b, c, d, e, f) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON (a, b, c, d, e, f, g) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON (a, b, c, d, e, f, g, h) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON (a, b, c, d, e, f, g, h, i) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON (a, b, c, d, e, f, g, h, i, j) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON (a, b, c, d, e, f, g, h, i, j, k) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n, FromJSON o) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] #

# 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)) #