module Data.EDN.Types (
Value(..), Tagged(..), TaggedValue,
EDNList, EDNVec, EDNSet, EDNMap, Pair,
setTag, getTag, stripTag,
tag, notag,
nil,
bool, true, false,
char, string,
symbol, symbolNS, keyword,
integer, floating,
makeList, makeVec, makeSet, makeMap
) where
import Data.String (IsString(..))
import Data.Text (Text)
import qualified Data.Text as T
import Data.ByteString.Char8 (ByteString)
import qualified Data.ByteString.Char8 as BS
import qualified Data.Vector as V
import qualified Data.Map as M
import qualified Data.Set as S
data Tagged a = NoTag !a
| Tagged !a !ByteString !ByteString
deriving (Eq, Ord, Show)
instance Functor Tagged where
fmap f (NoTag v) = NoTag (f v)
fmap f (Tagged v ns t) = Tagged (f v) ns t
type TaggedValue = Tagged Value
type EDNList = [TaggedValue]
type EDNVec = V.Vector TaggedValue
type EDNMap = M.Map Value TaggedValue
type EDNSet = S.Set TaggedValue
data Value = Nil
| Boolean !Bool
| String !Text
| Character !Char
| Symbol !ByteString !ByteString
| Keyword !ByteString
| Integer !Integer
| Floating !Double
| List EDNList
| Vec !EDNVec
| Map !EDNMap
| Set !EDNSet
deriving (Eq, Ord, Show)
instance IsString Value where
fromString (':':s) = Keyword . BS.pack $ s
fromString s = String . T.pack $ s
instance IsString (Tagged Value) where
fromString = string . T.pack
nil :: TaggedValue
nil = NoTag Nil
bool :: Bool -> TaggedValue
bool = NoTag . Boolean
true :: TaggedValue
true = bool True
false :: TaggedValue
false = bool False
char :: Char -> TaggedValue
char = NoTag . Character
string :: Text -> TaggedValue
string = NoTag . String
symbolNS :: ByteString -> ByteString -> TaggedValue
symbolNS ns value = NoTag $ Symbol ns value
symbol :: ByteString -> TaggedValue
symbol = symbolNS BS.empty
keyword :: ByteString -> TaggedValue
keyword = NoTag . Keyword
integer :: Integer -> TaggedValue
integer = NoTag . Integer
floating :: Double -> TaggedValue
floating = NoTag . Floating
tag :: ByteString -> ByteString -> a -> Tagged a
tag ns t value = Tagged value ns t
notag :: a -> Tagged a
notag = NoTag
setTag :: ByteString -> ByteString -> Tagged a -> Tagged a
setTag ns t (NoTag v) = tag ns t v
setTag ns t (Tagged v _ _) = tag ns t v
getTag :: TaggedValue -> (ByteString, ByteString)
getTag (NoTag _) = (BS.empty, BS.empty)
getTag (Tagged _ ns t) = (ns, t)
stripTag :: Tagged a -> a
stripTag (NoTag v) = v
stripTag (Tagged v _ _) = v
makeList :: [TaggedValue] -> Value
makeList = List
makeVec :: [TaggedValue] -> Value
makeVec = Vec . V.fromList
makeSet :: [TaggedValue] -> Value
makeSet = Set . S.fromList
type Pair = (Value, TaggedValue)
makeMap :: [Pair] -> Value
makeMap = Map . M.fromList