{-# LANGUAGE DeriveDataTypeable #-}

module Data.EDN.AST.Types.Value
  ( TaggedValue
  , Value(..)
  , EDNList
  , EDNVec
  , EDNMap
  , EDNSet
  , mkList
  , mkVec
  , mkMap
  , mkSet
  ) where

import Data.Data (Data)
import Data.Foldable (toList)
import Data.Text (Text)

import qualified Data.Map.Strict as M
import qualified Data.Set as S
import qualified Data.Vector as V

import Data.EDN.AST.Types.Tagged (Tagged)

type TaggedValue = Tagged Text Value

data Value
  = Nil                   -- ^ @ nil               @
  | Boolean   !Bool       -- ^ @ true | false      @
  | String    !Text       -- ^ @ "a string"        @
  | Character !Char       -- ^ @ \c                @
  | Symbol    !Text !Text -- ^ @ a-prefix/a-symbol @
  | Keyword   !Text       -- ^ @ :a-keyword        @
  | Integer   !Int        -- ^ @ 42                @
  | Floating  !Double     -- ^ @ 3.14              @
  | List      !EDNList    -- ^ @ (a list)          @
  | Vec       !EDNVec     -- ^ @ [a vector]        @
  | Map       !EDNMap     -- ^ @ {:a map}          @
  | Set       !EDNSet     -- ^ @ #{a set}          @
  deriving (Value -> Value -> Bool
(Value -> Value -> Bool) -> (Value -> Value -> Bool) -> Eq Value
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c== :: Value -> Value -> Bool
Eq, Eq Value
Eq Value
-> (Value -> Value -> Ordering)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Value)
-> (Value -> Value -> Value)
-> Ord Value
Value -> Value -> Bool
Value -> Value -> Ordering
Value -> Value -> Value
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Value -> Value -> Value
$cmin :: Value -> Value -> Value
max :: Value -> Value -> Value
$cmax :: Value -> Value -> Value
>= :: Value -> Value -> Bool
$c>= :: Value -> Value -> Bool
> :: Value -> Value -> Bool
$c> :: Value -> Value -> Bool
<= :: Value -> Value -> Bool
$c<= :: Value -> Value -> Bool
< :: Value -> Value -> Bool
$c< :: Value -> Value -> Bool
compare :: Value -> Value -> Ordering
$ccompare :: Value -> Value -> Ordering
$cp1Ord :: Eq Value
Ord, Int -> Value -> ShowS
[Value] -> ShowS
Value -> String
(Int -> Value -> ShowS)
-> (Value -> String) -> ([Value] -> ShowS) -> Show Value
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Value] -> ShowS
$cshowList :: [Value] -> ShowS
show :: Value -> String
$cshow :: Value -> String
showsPrec :: Int -> Value -> ShowS
$cshowsPrec :: Int -> Value -> ShowS
Show, Typeable Value
DataType
Constr
Typeable Value
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Value -> c Value)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Value)
-> (Value -> Constr)
-> (Value -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Value))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value))
-> ((forall b. Data b => b -> b) -> Value -> Value)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r)
-> (forall u. (forall d. Data d => d -> u) -> Value -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Value -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Value -> m Value)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value -> m Value)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value -> m Value)
-> Data Value
Value -> DataType
Value -> Constr
(forall b. Data b => b -> b) -> Value -> Value
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value -> c Value
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Value
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Value -> u
forall u. (forall d. Data d => d -> u) -> Value -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Value -> m Value
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value -> m Value
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Value
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value -> c Value
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Value)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value)
$cSet :: Constr
$cMap :: Constr
$cVec :: Constr
$cList :: Constr
$cFloating :: Constr
$cInteger :: Constr
$cKeyword :: Constr
$cSymbol :: Constr
$cCharacter :: Constr
$cString :: Constr
$cBoolean :: Constr
$cNil :: Constr
$tValue :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Value -> m Value
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value -> m Value
gmapMp :: (forall d. Data d => d -> m d) -> Value -> m Value
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value -> m Value
gmapM :: (forall d. Data d => d -> m d) -> Value -> m Value
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Value -> m Value
gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Value -> u
gmapQ :: (forall d. Data d => d -> u) -> Value -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Value -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r
gmapT :: (forall b. Data b => b -> b) -> Value -> Value
$cgmapT :: (forall b. Data b => b -> b) -> Value -> Value
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Value)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Value)
dataTypeOf :: Value -> DataType
$cdataTypeOf :: Value -> DataType
toConstr :: Value -> Constr
$ctoConstr :: Value -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Value
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Value
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value -> c Value
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value -> c Value
$cp1Data :: Typeable Value
Data)

type EDNList = [TaggedValue]
type EDNVec  = V.Vector TaggedValue
type EDNMap  = M.Map TaggedValue TaggedValue
type EDNSet  = S.Set TaggedValue

mkList :: Foldable f => f TaggedValue -> Value
mkList :: f TaggedValue -> Value
mkList = EDNList -> Value
List (EDNList -> Value)
-> (f TaggedValue -> EDNList) -> f TaggedValue -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f TaggedValue -> EDNList
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList

mkVec :: Foldable f => f TaggedValue -> Value
mkVec :: f TaggedValue -> Value
mkVec = EDNVec -> Value
Vec (EDNVec -> Value)
-> (f TaggedValue -> EDNVec) -> f TaggedValue -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EDNList -> EDNVec
forall a. [a] -> Vector a
V.fromList (EDNList -> EDNVec)
-> (f TaggedValue -> EDNList) -> f TaggedValue -> EDNVec
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f TaggedValue -> EDNList
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList

mkMap :: Foldable f => f (TaggedValue, TaggedValue) -> Value
mkMap :: f (TaggedValue, TaggedValue) -> Value
mkMap = EDNMap -> Value
Map (EDNMap -> Value)
-> (f (TaggedValue, TaggedValue) -> EDNMap)
-> f (TaggedValue, TaggedValue)
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TaggedValue, TaggedValue)] -> EDNMap
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(TaggedValue, TaggedValue)] -> EDNMap)
-> (f (TaggedValue, TaggedValue) -> [(TaggedValue, TaggedValue)])
-> f (TaggedValue, TaggedValue)
-> EDNMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f (TaggedValue, TaggedValue) -> [(TaggedValue, TaggedValue)]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList

mkSet :: Foldable f => f TaggedValue -> Value
mkSet :: f TaggedValue -> Value
mkSet = EDNSet -> Value
Set (EDNSet -> Value)
-> (f TaggedValue -> EDNSet) -> f TaggedValue -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EDNList -> EDNSet
forall a. Ord a => [a] -> Set a
S.fromList (EDNList -> EDNSet)
-> (f TaggedValue -> EDNList) -> f TaggedValue -> EDNSet
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f TaggedValue -> EDNList
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList