Data.EDN.Types.Class

Type conversion

class ToEDN a where

A type that can be converted to JSON.

Methods

toEDN :: a -> TaggedValue

toEDNv :: a -> Value

Instances

ToEDN Bool

ToEDN Char

ToEDN Double

ToEDN Int

ToEDN Integer

ToEDN ()

ToEDN ByteString

ToEDN ByteString

ToEDN Text

ToEDN Text

ToEDN UTCTime

ToEDN Value

ToEDN TaggedValue

ToEDN [Char]

ToEDN a => ToEDN [a]

ToEDN a => ToEDN (Maybe a)

(Ord a, ToEDN a) => ToEDN (Set a)

ToEDN a => ToEDN (Vector a)

ToEDN a => ToEDN (Tagged a)

(ToEDN a, ToEDN b) => ToEDN (Either a b)

(ToEDN a, ToEDN b) => ToEDN (a, b)

(ToEDN a, ToEDN b) => ToEDN (Map a b)

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

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

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

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

(ToEDN a, ToEDN b, ToEDN c, ToEDN d, ToEDN e, ToEDN f, ToEDN g) => ToEDN (a, b, c, d, e, f, g)

(ToEDN a, ToEDN b, ToEDN c, ToEDN d, ToEDN e, ToEDN f, ToEDN g, ToEDN h) => ToEDN (a, b, c, d, e, f, g, h)

class FromEDN a where

A type that can be converted from EDN, with a possibility of failure.

When writing an instance, use empty, mzero, or fail to make a conversion fail, e.g. if an Map is missing a required key, or the value is of the wrong type.

Methods

parseEDN :: TaggedValue -> Parser a

parseEDNv :: Value -> Parser a

Instances

FromEDN Bool

FromEDN Char

FromEDN Double

FromEDN Int

FromEDN Integer

FromEDN ()

FromEDN ByteString

FromEDN ByteString

FromEDN Text

FromEDN Text

FromEDN UTCTime

FromEDN Value

FromEDN TaggedValue

FromEDN [Char]

FromEDN a => FromEDN [a]

FromEDN a => FromEDN (Maybe a)

(Ord a, FromEDN a) => FromEDN (Set a)

FromEDN a => FromEDN (Vector a)

FromEDN a => FromEDN (Tagged a)

(FromEDN a, FromEDN b) => FromEDN (Either a b)

(FromEDN a, FromEDN b) => FromEDN (a, b)

(Ord a, FromEDN a, FromEDN b) => FromEDN (Map a b)

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

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

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

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

(FromEDN a, FromEDN b, FromEDN c, FromEDN d, FromEDN e, FromEDN f, FromEDN g) => FromEDN (a, b, c, d, e, f, g)

(FromEDN a, FromEDN b, FromEDN c, FromEDN d, FromEDN e, FromEDN f, FromEDN g, FromEDN h) => FromEDN (a, b, c, d, e, f, g, h)

fromEDN :: FromEDN a => TaggedValue -> Result a

Convert a value from TaggedValue, failing if the types do not match.

fromEDNv :: FromEDN a => Value -> Result a

Convert a value from Value, failing if the types do not match.

EDN value decoding

decode :: FromEDN a => ByteString -> Maybe a

Deserializes a EDN value from a lazy ByteString. If this fails to to incomplete or invalid input, Nothing is returned.

eitherDecode :: FromEDN a => ByteString -> Either String a

Deserializes a EDN value from a lazy ByteString. If this fails to to incomplete or invalid input, Left is returned with an error message.

parse :: (a -> Parser b) -> a -> Result b

Run a Parser.

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

Run a Parser with an Either result type.

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

Run a Parser with a Maybe result type.

data Parser a

A continuation-based parser type.

Instances

Monad Parser

Functor Parser

MonadPlus Parser

Applicative Parser

Alternative Parser

Monoid (Parser a)

data Result a

The result of running a Parser.

Constructors

Error String

Success a

Instances

Monad Result

Functor Result

Typeable1 Result

MonadPlus Result

Applicative Result

Alternative Result

Eq a => Eq (Result a)

Show a => Show (Result a)

Monoid (Result a)

NFData a => NFData (Result a)

Convenience functions

(.=) :: ToEDN a => ByteString -> a -> Pair

Construct a Pair from a key (as EDN keyword) and a value.

(.:) :: (Show k, ToEDN k, FromEDN a) => EDNMap -> k -> Parser a

Retrieve the value associated with the given key of an EDNMap. 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.

(.:?) :: (ToEDN k, FromEDN a) => EDNMap -> k -> Parser (Maybe a)

Retrieve the value associated with the given key of an EDNMap. 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"

typeMismatch

Arguments

:: String

The name of the type you are trying to parse.

-> Value

The actual value encountered.

-> Parser a

Fail parsing due to a type mismatch, with a descriptive message.