Text.JSON.FromJSValue

Interface for extracting data from JSValue.

Basic Parsing

class FromJSValue a where

Structures that can be parsed from JSON. Instances must declare either fromJSValue (parse directly from JSValue) or fromJSValueM (uses MonadReader).

Example implementation:

data D = D String Int

instance FromJSValue D where
  fromJSValue = do
    s <- fromJSValueField "string_key"
    i <- fromJSValueField "int_key"
    return (D <$> s <*> i)

Note that we make use of MonadReader instance for "(->)" and of Applicative programming style with <$> and <*>.

Note: fromJSValueM is deprecated, in future fromJSValue will be generalized to work in any MonadReader JSValue.

Minimal complete definition

Nothing

Methods

fromJSValue :: JSValue -> Maybe a

fromJSValueM :: MonadReader JSValue m => m (Maybe a)

Instances

FromJSValue Bool

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Bool

fromJSValueM :: MonadReader JSValue m => m (Maybe Bool)

FromJSValue Double

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Double

fromJSValueM :: MonadReader JSValue m => m (Maybe Double)

FromJSValue Float

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Float

fromJSValueM :: MonadReader JSValue m => m (Maybe Float)

FromJSValue Int

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Int

fromJSValueM :: MonadReader JSValue m => m (Maybe Int)

FromJSValue Int16

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Int16

fromJSValueM :: MonadReader JSValue m => m (Maybe Int16)

FromJSValue Int32

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Int32

fromJSValueM :: MonadReader JSValue m => m (Maybe Int32)

FromJSValue Int64

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Int64

fromJSValueM :: MonadReader JSValue m => m (Maybe Int64)

FromJSValue Integer

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Integer

fromJSValueM :: MonadReader JSValue m => m (Maybe Integer)

FromJSValue Word

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Word

fromJSValueM :: MonadReader JSValue m => m (Maybe Word)

FromJSValue Word16

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Word16

fromJSValueM :: MonadReader JSValue m => m (Maybe Word16)

FromJSValue Word32

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Word32

fromJSValueM :: MonadReader JSValue m => m (Maybe Word32)

FromJSValue Word64

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe Word64

fromJSValueM :: MonadReader JSValue m => m (Maybe Word64)

FromJSValue String

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe String

fromJSValueM :: MonadReader JSValue m => m (Maybe String)

FromJSValue ByteString

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe ByteString

fromJSValueM :: MonadReader JSValue m => m (Maybe ByteString)

FromJSValue JSValue

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe JSValue

fromJSValueM :: MonadReader JSValue m => m (Maybe JSValue)

FromJSValue a => FromJSValue [a]

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe [a]

fromJSValueM :: MonadReader JSValue m => m (Maybe [a])

FromJSValue a => FromJSValue (Maybe a)

Parsing any Maybe always returns Just

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe (Maybe a)

fromJSValueM :: MonadReader JSValue m => m (Maybe (Maybe a))

(FromJSValue a, FromJSValue b) => FromJSValue (a, b)

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe (a, b)

fromJSValueM :: MonadReader JSValue m => m (Maybe (a, b))

(FromJSValue a, FromJSValue b, FromJSValue c) => FromJSValue (a, b, c)

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe (a, b, c)

fromJSValueM :: MonadReader JSValue m => m (Maybe (a, b, c))

(FromJSValue a, FromJSValue b, FromJSValue c, FromJSValue d) => FromJSValue (a, b, c, d)

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe (a, b, c, d)

fromJSValueM :: MonadReader JSValue m => m (Maybe (a, b, c, d))

(FromJSValue a, FromJSValue b, FromJSValue c, FromJSValue d, FromJSValue e) => FromJSValue (a, b, c, d, e)

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe (a, b, c, d, e)

fromJSValueM :: MonadReader JSValue m => m (Maybe (a, b, c, d, e))

(FromJSValue a, FromJSValue b, FromJSValue c, FromJSValue d, FromJSValue e, FromJSValue f) => FromJSValue (a, b, c, d, e, f)

Defined in Text.JSON.FromJSValue

Methods

fromJSValue :: JSValue -> Maybe (a, b, c, d, e, f)

fromJSValueM :: MonadReader JSValue m => m (Maybe (a, b, c, d, e, f))

class FromJSValueWithUpdate a where

Structures that can be parsed from JSON, fields absent in the JSON will be filled in using (optional) original structure.

By convention JSON null should be treated as a request to reset structure element to default value.

Minimal complete definition

Nothing

Methods

fromJSValueWithUpdate :: Maybe a -> JSValue -> Maybe a

fromJSValueWithUpdateM :: MonadReader JSValue m => Maybe a -> m (Maybe a)

class MatchWithJSValue a where

Structures that can be matched with JSValue

Minimal complete definition

Nothing

Methods

matchesWithJSValue :: a -> JSValue -> Bool

matchesWithJSValueM :: MonadReader JSValue m => a -> m Bool

Data Extraction

jsValueField :: (MonadReader JSValue m, FromJSValue a) => String -> m (Maybe (Maybe a))

Reading the value that is on some field. Returns Nothing if JSON is not an object or field is present but cannot be parsed, 'Just Nothing' if absent, and 'Just (Just a)' otherwise

fromJSValueField :: (MonadReader JSValue m, FromJSValue a) => String -> m (Maybe a)

Reading the value that is on a field. Semantics are a bit involved, example GHCi session should clarify:

Prelude> :set -XNoMonomorphismRestriction
Prelude> let x = withJSValue (JSObject (toJSObject [("key",JSString $ toJSString "value")]))
Prelude> x (fromJSValueField "key") :: IO (Maybe Int)
Nothing
Prelude> x (fromJSValueField "key") :: IO (Maybe (Maybe Int))
Just Nothing
Prelude> x (fromJSValueField "key") :: IO (Maybe (Maybe (Maybe Int)))
Just (Just Nothing)
Prelude> x (fromJSValueField "key") :: IO (Maybe String)
Just "value"
Prelude> x (fromJSValueField "key") :: IO (Maybe (Maybe String))
Just (Just "value")
Prelude> x (fromJSValueField "key") :: IO (Maybe (Maybe (Maybe String)))
Just (Just (Just "value"))
Prelude> let x = withJSValue (JSArray [])
Prelude> x (fromJSValueField "key") :: IO (Maybe String)
Nothing
Prelude> x (fromJSValueField "key") :: IO (Maybe (Maybe String))
Nothing
Prelude> x (fromJSValueField "key") :: IO (Maybe (Maybe (Maybe String)))
Nothing

fromJSValueFieldBase64 :: MonadReader JSValue m => String -> m (Maybe ByteString)

Version of fromJSValueField for Base64 encoded data to avoid memory leak.

fromJSValueFieldCustom :: MonadReader JSValue m => String -> m (Maybe a) -> m (Maybe a)

Generalization of fromJSValueField. Does not use FromJSValue instances.

fromJSValueCustomMany :: MonadReader JSValue m => m (Maybe a) -> m (Maybe [a])

Runs parser on each element of underlaying json. Returns Just iff JSON is array.

fromJSValueCustomList :: MonadReader JSValue m => [m (Maybe a)] -> m (Maybe [a])

Generalization of fromJSValueCustomMany, where each element of array can have different parser.

fromJSValueManyWithUpdate :: (MonadReader JSValue m, FromJSValueWithUpdate a, MatchWithJSValue a) => [a] -> m (Maybe [a])

Runs parser on each element of underlying json. Returns Just iff JSON is an array.

Note: This method has quadratic complexity. It is better to write less general matching algorithms that use Maps.

Running

withJSValue :: Monad m => JSValue -> ReaderT JSValue m a -> m a

Simple runner. Example:

let (v :: MyStruct) = runIdentity $ withJSValue js (fromJSValueM)

or inline:

let z = runIdentity $ withJSValue js $ do
            a <- fromJSValueField "a"
            b <- fromJSValueField "b"
            c <- fromJSValueField "c"
            return ((,,) <$> a <*> b <*> c)

or using the monad transformer:

z <- withJSValue js $ do
            a <- fromJSValueField "a"
            b <- fromJSValueField "b"
            c <- fromJSValueField "c"
            return ((,,) <$> a <*> b <*> c)