Data.EDN

Core EDN types

data Value

A "raw" EDN value represented as a Haskell value.

Constructors

Nil

Boolean !Bool

String !Text

Character !Char

Symbol !ByteString !ByteString

Keyword !ByteString

Integer !Integer

Floating !Double

List EDNList

Vec !EDNVec

Map !EDNMap

Set !EDNSet

Instances

Eq Value

Ord Value

Show Value

IsString Value

Strings starting with ":" will become keywords.

FromEDN Value

FromEDN TaggedValue

ToEDN Value

ToEDN TaggedValue

IsString (Tagged Value)

Strings will become an tagless EDN strings.

type TaggedValue = Tagged Value

data Tagged a

Abstract namespaced tag.

Constructors

NoTag !a

Tagged !a !ByteString !ByteString

Instances

Functor Tagged

FromEDN TaggedValue

ToEDN TaggedValue

Eq a => Eq (Tagged a)

(Eq (Tagged a), Ord a) => Ord (Tagged a)

Show a => Show (Tagged a)

IsString (Tagged Value)

Strings will become an tagless EDN strings.

FromEDN a => FromEDN (Tagged a)

ToEDN a => ToEDN (Tagged a)

Type conversion

class ToEDN a where

Methods

toEDN :: a -> TaggedValue

Instances

ToEDN Bool

ToEDN Char

ToEDN Double

ToEDN Integer

ToEDN ()

ToEDN ByteString

ToEDN ByteString

ToEDN Text

ToEDN Text

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 (Map a b)

class FromEDN a

Instances

FromEDN Bool

FromEDN Char

FromEDN Double

FromEDN Integer

FromEDN ()

FromEDN ByteString

FromEDN ByteString

FromEDN Text

FromEDN Text

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)

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

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.

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

Tag manipulation

setTag :: ByteString -> ByteString -> Tagged a -> Tagged a

Replace a tag on a Tagged value.

getTag :: TaggedValue -> (ByteString, ByteString)

Extract namespace and tag from a tagged container. Will be a pair of empty for tagless containers.

stripTag :: Tagged a -> a

Extract bare value from a tagged or tagless container.

Constructors

tag :: ByteString -> ByteString -> a -> Tagged a

Attach a namespaced tag to a value.

notag :: a -> Tagged a

Wrap a value into tagless container.

Basic values

nil :: TaggedValue

Basic EDN nil.

bool :: Bool -> TaggedValue

Basic EDN boolean.

true :: TaggedValue

Const EDN True.

false :: TaggedValue

Const EDN False.

char :: Char -> TaggedValue

Basic EDN character.

string :: Text -> TaggedValue

Basic EDN string.

symbol :: ByteString -> TaggedValue

"Bare" symbol.

symbolNS :: ByteString -> ByteString -> TaggedValue

A namespaced symbol.

keyword :: ByteString -> TaggedValue

Basic EDN keyword.

integer :: Integer -> TaggedValue

Basic EDN integer.

floating :: Double -> TaggedValue

Basic EDN fp number.

Containers

makeList :: [TaggedValue] -> Value

Create an EDN List from a Value list wrapping them into empty tags.

makeVec :: [TaggedValue] -> Value

Create an EDN Vector from a TaggedValue list.

makeSet :: [TaggedValue] -> Value

Create an EDN Set from a TaggedValue list.

makeMap :: [Pair] -> Value

Create an EDN Map from a assoc list with untagged keys and tagged values.

(.=) :: ByteString -> TaggedValue -> Pair

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

Encoding

encode :: TaggedValue -> ByteString

Serialize a EDN value as a lazy ByteString.

fromValue :: Value -> Builder

Encode a raw EDN value to a Builder.

fromTagged :: TaggedValue -> Builder

Encode a Tagged EDN value to a Builder.

Parsing

decode :: ByteString -> Maybe TaggedValue

Decode a lazy ByteString into a TaggedValue. If fails due to incomplete or invalid input, Nothing is returned.

parseValue :: Parser Value

Parse a "raw" EDN value into a Value.

parseTagged :: Parser TaggedValue

Parse a probably tagged EDN value into a TaggedValue.

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)