lens-aeson-0.1.2: Law-abiding lenses for aeson

Portability | non-portable
Stability | experimental
Maintainer | Edward Kmett <ekmett@gmail.com>
Safe Haskell | Trustworthy

Control.Lens.Aeson

Contents

- Numbers
- Primitive
- Objects and Arrays
- Decoding

Description

Synopsis

- class AsNumber t where
  - _Number :: Prism' t Number
  - _Double :: Prism' t Double
  - _Integer :: Prism' t Integer
- integralValue :: (AsNumber t, Integral a) => Prism' t a
- nonNull :: Prism' Value Value
- data Primitive
  - = StringPrim !Text
  - | NumberPrim !Number
  - | BoolPrim !Bool
  - | NullPrim
- class AsNumber t => AsPrimitive t where
  - _Primitive :: Prism' t Primitive
  - _String :: Prism' t Text
  - _Bool :: Prism' t Bool
  - _Null :: Prism' t ()
- class AsPrimitive t => AsValue t where
  - _Value :: Prism' t Value
  - _Object :: Prism' t (HashMap Text Value)
  - _Array :: Prism' t (Vector Value)
- key :: AsValue t => Text -> Traversal' t Value
- members :: AsValue t => IndexedTraversal' Text t Value
- nth :: AsValue t => Int -> Traversal' t Value
- values :: AsValue t => IndexedTraversal' Int t Value
- class AsJSON t where
  - _JSON :: (FromJSON a, ToJSON a) => Prism' t a

# Numbers

class AsNumber t where Source

Methods

_Number :: Prism' t Number Source

    >>> "[1, \"x\"]" ^? nth 0 . _Number
    Just 1

    >>> "[1, \"x\"]" ^? nth 1 . _Number
    Nothing

_Double :: Prism' t Double Source

Prism into an `Double` over a `Value`, `Primitive` or `Number`

    >>> "[10.2]" ^? nth 0 . _Double
    Just 10.2

_Integer :: Prism' t Integer Source

Prism into an `Integer` over a `Value`, `Primitive` or `Number`

    >>> "[10]" ^? nth 0 . _Integer
    Just 10

    >>> "[10.5]" ^? nth 0 . _Integer
    Nothing

Instances

AsNumber String |
AsNumber ByteString |
AsNumber Number |
AsNumber Value |
AsNumber Primitive |

integralValue :: (AsNumber t, Integral a) => Prism' t aSource

Access Integer `Value`s as Integrals.

defined as `integer . `integral'`

    >>> "[10]" ^? nth 0 . integralValue
    Just 10

    >>> "[10.5]" ^? nth 0 . integralValue
    Nothing

nonNull :: Prism' Value Value Source

Prism into non-`Null` values

    >>> "{\"a\": \"xyz\", \"b\": null}" ^? key "a" . nonNull
    Just (String "xyz")

    >>> "{\"a\": {}, \"b\": null}" ^? key "a" . nonNull
    Just (Object fromList [])

    >>> "{\"a\": \"xyz\", \"b\": null}" ^? key "b" . nonNull
    Nothing

# Primitive

data Primitive Source

Primitives of `Value`

Constructors

StringPrim !Text |
NumberPrim !Number |
BoolPrim !Bool |
NullPrim |

Instances

Eq Primitive |
Data Primitive |
Ord Primitive |
Show Primitive |
Typeable Primitive |
AsPrimitive Primitive |
AsNumber Primitive |

class AsNumber t => AsPrimitive t where Source

Methods

_Primitive :: Prism' t Primitive Source

    >>> "[1, \"x\", null, true, false]" ^? nth 0 . _Primitive
    Just (NumberPrim 1)

    >>> "[1, \"x\", null, true, false]" ^? nth 1 . _Primitive
    Just (StringPrim "x")

    >>> "[1, \"x\", null, true, false]" ^? nth 2 . _Primitive
    Just NullPrim

    >>> "[1, \"x\", null, true, false]" ^? nth 3 . _Primitive
    Just (BoolPrim True)

    >>> "[1, \"x\", null, true, false]" ^? nth 4 . _Primitive
    Just (BoolPrim False)

_String :: Prism' t TextSource

_Bool :: Prism' t Bool Source

_Null :: Prism' t ()Source

Instances

AsPrimitive String |
AsPrimitive ByteString |
AsPrimitive Value |
AsPrimitive Primitive |

# Objects and Arrays

class AsPrimitive t => AsValue t where Source

Methods

_Value :: Prism' t Value Source

    >>> "[1,2,3]" ^? _Value
    Just (Array (fromList [Number 1,Number 2,Number 3]))

_Object :: Prism' t (HashMap Text Value)Source

    >>> "{\"a\": {}, \"b\": null}" ^? key "a" . _Object
    Just fromList []

    >>> "{\"a\": {}, \"b\": null}" ^? key "b" . _Object
    Nothing

_Array :: Prism' t (Vector Value)Source

    >>> "[1,2,3]" ^? _Array
    Just (fromList [Number 1,Number 2,Number 3])

Instances

AsValue String |
AsValue ByteString |
AsValue Value |

key :: AsValue t => Text -> Traversal' t Value Source

Like `ix`, but for `Object` with Text indices. This often has better inference than `ix` when used with OverloadedStrings.

    >>> "{\"a\": 100, \"b\": 200}" ^? key "a"
    Just (Number 100)

    >>> "[1,2,3]" ^? key "a"
    Nothing

members :: AsValue t => IndexedTraversal' Text t Value Source

nth :: AsValue t => Int -> Traversal' t Value Source

Like `ix`, but for Arrays with Int indexes

    >>> "[1,2,3]" ^? nth 1
    Just (Number 2)

    >>> "\"a\": 100, \"b\": 200}" ^? nth 1
    Nothing

    >>> "[1,2,3]" & nth 1 .~ (Number 20)
    "[1,20,3]"

values :: AsValue t => IndexedTraversal' Int t Value Source

# Decoding

class AsJSON t where Source

Methods

_JSON :: (FromJSON a, ToJSON a) => Prism' t aSource

A Prism into `Value` on lazy `ByteString`s.

Instances

AsJSON String |
AsJSON ByteString |