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

Methods

toEDN :: Bool -> TaggedValue

toEDNv :: Bool -> Value

ToEDN Char

Methods

toEDN :: Char -> TaggedValue

toEDNv :: Char -> Value

ToEDN Double

Methods

toEDN :: Double -> TaggedValue

toEDNv :: Double -> Value

ToEDN Int

Methods

toEDN :: Int -> TaggedValue

toEDNv :: Int -> Value

ToEDN Integer

Methods

toEDN :: Integer -> TaggedValue

toEDNv :: Integer -> Value

ToEDN ()

Methods

toEDN :: () -> TaggedValue

toEDNv :: () -> Value

ToEDN ByteString

Methods

toEDN :: ByteString -> TaggedValue

toEDNv :: ByteString -> Value

ToEDN ByteString

Methods

toEDN :: ByteString -> TaggedValue

toEDNv :: ByteString -> Value

ToEDN Text

Methods

toEDN :: Text -> TaggedValue

toEDNv :: Text -> Value

ToEDN Text

Methods

toEDN :: Text -> TaggedValue

toEDNv :: Text -> Value

ToEDN UTCTime

Methods

toEDN :: UTCTime -> TaggedValue

toEDNv :: UTCTime -> Value

ToEDN Value

Methods

toEDN :: Value -> TaggedValue

toEDNv :: Value -> Value

ToEDN TaggedValue

Methods

toEDN :: TaggedValue -> TaggedValue

toEDNv :: TaggedValue -> Value

ToEDN [Char]

Methods

toEDN :: [Char] -> TaggedValue

toEDNv :: [Char] -> Value

ToEDN a => ToEDN [a]

Methods

toEDN :: [a] -> TaggedValue

toEDNv :: [a] -> Value

ToEDN a => ToEDN (Maybe a)

Methods

toEDN :: Maybe a -> TaggedValue

toEDNv :: Maybe a -> Value

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

Methods

toEDN :: Set a -> TaggedValue

toEDNv :: Set a -> Value

ToEDN a => ToEDN (Vector a)

Methods

toEDN :: Vector a -> TaggedValue

toEDNv :: Vector a -> Value

ToEDN a => ToEDN (Tagged a)

Methods

toEDN :: Tagged a -> TaggedValue

toEDNv :: Tagged a -> Value

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

Methods

toEDN :: Either a b -> TaggedValue

toEDNv :: Either a b -> Value

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

Methods

toEDN :: (a, b) -> TaggedValue

toEDNv :: (a, b) -> Value

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

Methods

toEDN :: Map a b -> TaggedValue

toEDNv :: Map a b -> Value

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

Methods

toEDN :: (a, b, c) -> TaggedValue

toEDNv :: (a, b, c) -> Value

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

Methods

toEDN :: (a, b, c, d) -> TaggedValue

toEDNv :: (a, b, c, d) -> Value

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

Methods

toEDN :: (a, b, c, d, e) -> TaggedValue

toEDNv :: (a, b, c, d, e) -> Value

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

Methods

toEDN :: (a, b, c, d, e, f) -> TaggedValue

toEDNv :: (a, b, c, d, e, f) -> Value

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

Methods

toEDN :: (a, b, c, d, e, f, g) -> TaggedValue

toEDNv :: (a, b, c, d, e, f, g) -> Value

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

Methods

toEDN :: (a, b, c, d, e, f, g, h) -> TaggedValue

toEDNv :: (a, b, c, d, e, f, g, h) -> Value

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

Methods

parseEDN :: TaggedValue -> Parser Bool

parseEDNv :: Value -> Parser Bool

FromEDN Char

Methods

parseEDN :: TaggedValue -> Parser Char

parseEDNv :: Value -> Parser Char

FromEDN Double

Methods

parseEDN :: TaggedValue -> Parser Double

parseEDNv :: Value -> Parser Double

FromEDN Int

Methods

parseEDN :: TaggedValue -> Parser Int

parseEDNv :: Value -> Parser Int

FromEDN Integer

Methods

parseEDN :: TaggedValue -> Parser Integer

parseEDNv :: Value -> Parser Integer

FromEDN ()

Methods

parseEDN :: TaggedValue -> Parser ()

parseEDNv :: Value -> Parser ()

FromEDN ByteString

Methods

parseEDN :: TaggedValue -> Parser ByteString

parseEDNv :: Value -> Parser ByteString

FromEDN ByteString

Methods

parseEDN :: TaggedValue -> Parser ByteString

parseEDNv :: Value -> Parser ByteString

FromEDN Text

Methods

parseEDN :: TaggedValue -> Parser Text

parseEDNv :: Value -> Parser Text

FromEDN Text

Methods

parseEDN :: TaggedValue -> Parser Text

parseEDNv :: Value -> Parser Text

FromEDN UTCTime

Methods

parseEDN :: TaggedValue -> Parser UTCTime

parseEDNv :: Value -> Parser UTCTime

FromEDN Value

Methods

parseEDN :: TaggedValue -> Parser Value

parseEDNv :: Value -> Parser Value

FromEDN TaggedValue

Methods

parseEDN :: TaggedValue -> Parser TaggedValue

parseEDNv :: Value -> Parser TaggedValue

FromEDN [Char]

Methods

parseEDN :: TaggedValue -> Parser [Char]

parseEDNv :: Value -> Parser [Char]

FromEDN a => FromEDN [a]

Methods

parseEDN :: TaggedValue -> Parser [a]

parseEDNv :: Value -> Parser [a]

FromEDN a => FromEDN (Maybe a)

Methods

parseEDN :: TaggedValue -> Parser (Maybe a)

parseEDNv :: Value -> Parser (Maybe a)

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

Methods

parseEDN :: TaggedValue -> Parser (Set a)

parseEDNv :: Value -> Parser (Set a)

FromEDN a => FromEDN (Vector a)

Methods

parseEDN :: TaggedValue -> Parser (Vector a)

parseEDNv :: Value -> Parser (Vector a)

FromEDN a => FromEDN (Tagged a)

Methods

parseEDN :: TaggedValue -> Parser (Tagged a)

parseEDNv :: Value -> Parser (Tagged a)

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

Methods

parseEDN :: TaggedValue -> Parser (Either a b)

parseEDNv :: Value -> Parser (Either a b)

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

Methods

parseEDN :: TaggedValue -> Parser (a, b)

parseEDNv :: Value -> Parser (a, b)

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

Methods

parseEDN :: TaggedValue -> Parser (Map a b)

parseEDNv :: Value -> Parser (Map a b)

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

Methods

parseEDN :: TaggedValue -> Parser (a, b, c)

parseEDNv :: Value -> Parser (a, b, c)

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

Methods

parseEDN :: TaggedValue -> Parser (a, b, c, d)

parseEDNv :: Value -> Parser (a, b, c, d)

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

Methods

parseEDN :: TaggedValue -> Parser (a, b, c, d, e)

parseEDNv :: Value -> Parser (a, b, c, d, e)

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

Methods

parseEDN :: TaggedValue -> Parser (a, b, c, d, e, f)

parseEDNv :: Value -> Parser (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)

Methods

parseEDN :: TaggedValue -> Parser (a, b, c, d, e, f, g)

parseEDNv :: Value -> Parser (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)

Methods

parseEDN :: TaggedValue -> Parser (a, b, c, d, e, f, g, h)

parseEDNv :: Value -> Parser (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

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

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

Monoid (Parser a)

Methods

mempty :: Parser a

mappend :: Parser a -> Parser a -> Parser a

mconcat :: [Parser a] -> Parser a

data Result a

The result of running a Parser.

Constructors

Error String

Success a

Instances

Monad Result

Methods

(>>=) :: Result a -> (a -> Result b) -> Result b

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

return :: a -> Result a

fail :: String -> Result a

Functor Result

Methods

fmap :: (a -> b) -> Result a -> Result b

(<$) :: a -> Result b -> Result a

Applicative Result

Methods

pure :: a -> Result a

(<*>) :: Result (a -> b) -> Result a -> Result b

(*>) :: Result a -> Result b -> Result b

(<*) :: Result a -> Result b -> Result a

Alternative Result

Methods

empty :: Result a

(<|>) :: Result a -> Result a -> Result a

some :: Result a -> Result [a]

many :: Result a -> Result [a]

MonadPlus Result

Methods

mzero :: Result a

mplus :: Result a -> Result a -> Result a

Eq a => Eq (Result a)

Methods

(==) :: Result a -> Result a -> Bool

(/=) :: Result a -> Result a -> Bool

Show a => Show (Result a)

Methods

showsPrec :: Int -> Result a -> ShowS

show :: Result a -> String

showList :: [Result a] -> ShowS

Monoid (Result a)

Methods

mempty :: Result a

mappend :: Result a -> Result a -> Result a

mconcat :: [Result a] -> Result a

NFData a => NFData (Result a)

Methods

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