Data.Greskell.GMap

This module defines types for parsing a "g:Map" GraphSON object. Usually users only have to use GMapEntry, because other types are just used internally to implement GraphSON parsers.

Since: 0.1.2.0

FlattenedMap

newtype FlattenedMap c k v

JSON encoding of a map as an array of flattened key-value pairs.

ToJSON instance of this type encodes the internal map as an array of keys and values. FromJSON instance of this type parses that flattened map.

• type c: container type for a map (e.g. Map and HashMap).
• type k: key of the map.
• type v: value of the map.

>>> let decode s = Aeson.eitherDecode s :: Either String (FlattenedMap HashMap Int String)
>>> let toSortedList = sort . HashMap.toList . unFlattenedMap
>>> fmap toSortedList $ decode "[10, \"ten\", 11, \"eleven\"]"
Right [(10,"ten"),(11,"eleven")]
>>> fmap toSortedList $ decode "[]"
Right []
>>> let (Left err_msg) = decode "[10, \"ten\", 11]"
>>> err_msg
...odd number of elements...
>>> Aeson.encode $ FlattenedMap $ (HashMap.fromList [(10, "ten")] :: HashMap Int String)
"[10,\"ten\"]"

Constructors

FlattenedMap

Fields

• unFlattenedMap :: c k v

Instances

Functor (c k) => Functor (FlattenedMap c k)

Defined in Data.Greskell.GMap

Methods

fmap :: (a -> b) -> FlattenedMap c k a -> FlattenedMap c k b

(<$) :: a -> FlattenedMap c k b -> FlattenedMap c k a

Foldable (c k) => Foldable (FlattenedMap c k)

Defined in Data.Greskell.GMap

Methods

fold :: Monoid m => FlattenedMap c k m -> m

foldMap :: Monoid m => (a -> m) -> FlattenedMap c k a -> m

foldr :: (a -> b -> b) -> b -> FlattenedMap c k a -> b

foldr' :: (a -> b -> b) -> b -> FlattenedMap c k a -> b

foldl :: (b -> a -> b) -> b -> FlattenedMap c k a -> b

foldl' :: (b -> a -> b) -> b -> FlattenedMap c k a -> b

foldr1 :: (a -> a -> a) -> FlattenedMap c k a -> a

foldl1 :: (a -> a -> a) -> FlattenedMap c k a -> a

toList :: FlattenedMap c k a -> [a]

null :: FlattenedMap c k a -> Bool

length :: FlattenedMap c k a -> Int

elem :: Eq a => a -> FlattenedMap c k a -> Bool

maximum :: Ord a => FlattenedMap c k a -> a

minimum :: Ord a => FlattenedMap c k a -> a

sum :: Num a => FlattenedMap c k a -> a

product :: Num a => FlattenedMap c k a -> a

Traversable (c k) => Traversable (FlattenedMap c k)

Defined in Data.Greskell.GMap

Methods

traverse :: Applicative f => (a -> f b) -> FlattenedMap c k a -> f (FlattenedMap c k b)

sequenceA :: Applicative f => FlattenedMap c k (f a) -> f (FlattenedMap c k a)

mapM :: Monad m => (a -> m b) -> FlattenedMap c k a -> m (FlattenedMap c k b)

sequence :: Monad m => FlattenedMap c k (m a) -> m (FlattenedMap c k a)

Eq (c k v) => Eq (FlattenedMap c k v)

Defined in Data.Greskell.GMap

Methods

(==) :: FlattenedMap c k v -> FlattenedMap c k v -> Bool

(/=) :: FlattenedMap c k v -> FlattenedMap c k v -> Bool

Ord (c k v) => Ord (FlattenedMap c k v)

Defined in Data.Greskell.GMap

Methods

compare :: FlattenedMap c k v -> FlattenedMap c k v -> Ordering

(<) :: FlattenedMap c k v -> FlattenedMap c k v -> Bool

(<=) :: FlattenedMap c k v -> FlattenedMap c k v -> Bool

(>) :: FlattenedMap c k v -> FlattenedMap c k v -> Bool

(>=) :: FlattenedMap c k v -> FlattenedMap c k v -> Bool

max :: FlattenedMap c k v -> FlattenedMap c k v -> FlattenedMap c k v

min :: FlattenedMap c k v -> FlattenedMap c k v -> FlattenedMap c k v

Show (c k v) => Show (FlattenedMap c k v)

Defined in Data.Greskell.GMap

Methods

showsPrec :: Int -> FlattenedMap c k v -> ShowS

show :: FlattenedMap c k v -> String

showList :: [FlattenedMap c k v] -> ShowS

(ToJSON k, ToJSON v, IsList (c k v), Item (c k v) ~ (k, v)) => ToJSON (FlattenedMap c k v)

Defined in Data.Greskell.GMap

Methods

toJSON :: FlattenedMap c k v -> Value

toEncoding :: FlattenedMap c k v -> Encoding

toJSONList :: [FlattenedMap c k v] -> Value

toEncodingList :: [FlattenedMap c k v] -> Encoding

(FromJSON k, FromJSON v, IsList (c k v), Item (c k v) ~ (k, v)) => FromJSON (FlattenedMap c k v)

Use parseToFlattenedMap.

Defined in Data.Greskell.GMap

Methods

parseJSON :: Value -> Parser (FlattenedMap c k v)

parseJSONList :: Value -> Parser [FlattenedMap c k v]

GraphSONTyped (FlattenedMap c k v)

Map to "g:Map".

Defined in Data.Greskell.GMap

Methods

gsonTypeFor :: FlattenedMap c k v -> Text

(FromGraphSON k, FromGraphSON v, IsList (c k v), Item (c k v) ~ (k, v)) => FromGraphSON (FlattenedMap c k v)

Use parseToFlattenedMap.

Defined in Data.Greskell.GraphSON

Methods

parseGraphSON :: GValue -> Parser (FlattenedMap c k v)

parseToFlattenedMap

Arguments

:: (IsList (c k v), Item (c k v) ~ (k, v))

=> (s -> Parser k)

key parser

-> (s -> Parser v)

value parser

-> Vector s

input vector of flattened key-values.

-> Parser (FlattenedMap c k v)

General parser for FlattenedMap.

GMap

data GMap c k v

Haskell representation of g:Map type.

GraphSON v1 and v2 encode Java Map type as a JSON Object, while GraphSON v3 encodes it as an array of flattened keys and values (like FlattenedMap.) GMap type handles both encoding schemes.

• type c: container type for a map (e.g. Map and HashMap).
• type k: key of the map.
• type v: value of the map.

>>> Aeson.eitherDecode "{\"ten\": 10}" :: Either String (GMap HashMap Text Int)
Right (GMap {gmapFlat = False, gmapValue = fromList [("ten",10)]})
>>> Aeson.eitherDecode "[\"ten\", 10]" :: Either String (GMap HashMap Text Int)
Right (GMap {gmapFlat = True, gmapValue = fromList [("ten",10)]})
>>> Aeson.encode $ GMap False (HashMap.fromList [(9, "nine")] :: HashMap Int Text)
"{\"9\":\"nine\"}"
>>> Aeson.encode $ GMap True (HashMap.fromList [(9, "nine")] :: HashMap Int Text)
"[9,\"nine\"]"

Constructors

GMap

Fields

• gmapFlat :: !Bool

  If True, the map is encoded as an array. If False, it's encoded as a JSON Object.

• gmapValue :: !(c k v)

  Map implementation.

Instances

Functor (c k) => Functor (GMap c k)

Defined in Data.Greskell.GMap

Methods

fmap :: (a -> b) -> GMap c k a -> GMap c k b

(<$) :: a -> GMap c k b -> GMap c k a

Foldable (c k) => Foldable (GMap c k)

Defined in Data.Greskell.GMap

Methods

fold :: Monoid m => GMap c k m -> m

foldMap :: Monoid m => (a -> m) -> GMap c k a -> m

foldr :: (a -> b -> b) -> b -> GMap c k a -> b

foldr' :: (a -> b -> b) -> b -> GMap c k a -> b

foldl :: (b -> a -> b) -> b -> GMap c k a -> b

foldl' :: (b -> a -> b) -> b -> GMap c k a -> b

foldr1 :: (a -> a -> a) -> GMap c k a -> a

foldl1 :: (a -> a -> a) -> GMap c k a -> a

toList :: GMap c k a -> [a]

null :: GMap c k a -> Bool

length :: GMap c k a -> Int

elem :: Eq a => a -> GMap c k a -> Bool

maximum :: Ord a => GMap c k a -> a

minimum :: Ord a => GMap c k a -> a

sum :: Num a => GMap c k a -> a

product :: Num a => GMap c k a -> a

Traversable (c k) => Traversable (GMap c k)

Defined in Data.Greskell.GMap

Methods

traverse :: Applicative f => (a -> f b) -> GMap c k a -> f (GMap c k b)

sequenceA :: Applicative f => GMap c k (f a) -> f (GMap c k a)

mapM :: Monad m => (a -> m b) -> GMap c k a -> m (GMap c k b)

sequence :: Monad m => GMap c k (m a) -> m (GMap c k a)

Eq (c k v) => Eq (GMap c k v)

Defined in Data.Greskell.GMap

Methods

(==) :: GMap c k v -> GMap c k v -> Bool

(/=) :: GMap c k v -> GMap c k v -> Bool

Show (c k v) => Show (GMap c k v)

Defined in Data.Greskell.GMap

Methods

showsPrec :: Int -> GMap c k v -> ShowS

show :: GMap c k v -> String

showList :: [GMap c k v] -> ShowS

(ToJSON k, ToJSON v, IsList (c k v), Item (c k v) ~ (k, v), ToJSON (c k v)) => ToJSON (GMap c k v)

Defined in Data.Greskell.GMap

Methods

toJSON :: GMap c k v -> Value

toEncoding :: GMap c k v -> Encoding

toJSONList :: [GMap c k v] -> Value

toEncodingList :: [GMap c k v] -> Encoding

(FromJSON k, FromJSON v, IsList (c k v), Item (c k v) ~ (k, v), FromJSON (c k v)) => FromJSON (GMap c k v)

Use parseToGMap.

Defined in Data.Greskell.GMap

Methods

parseJSON :: Value -> Parser (GMap c k v)

parseJSONList :: Value -> Parser [GMap c k v]

GraphSONTyped (GMap c k v)

Map to "g:Map".

Defined in Data.Greskell.GMap

Methods

gsonTypeFor :: GMap c k v -> Text

(FromGraphSON k, FromGraphSON v, IsList (c k v), Item (c k v) ~ (k, v), Traversable (c k), FromJSON (c k GValue)) => FromGraphSON (GMap c k v)

Use parseToGMap.

Defined in Data.Greskell.GraphSON

Methods

parseGraphSON :: GValue -> Parser (GMap c k v)

AsIterator (GMap c k v)

Defined in Data.Greskell.AsIterator

Associated Types

type IteratorItem (GMap c k v) :: Type

type IteratorItem (GMap c k v)

Defined in Data.Greskell.AsIterator

type IteratorItem (GMap c k v) = GMapEntry k v

unGMap :: GMap c k v -> c k v

Get the map implementation from GMap.

singleton :: (IsList (c k v), Item (c k v) ~ (k, v)) => GMapEntry k v -> GMap c k v

Create GMap that has the single GMapEntry.

toList :: (IsList (c k v), Item (c k v) ~ (k, v)) => GMap c k v -> [GMapEntry k v]

Deconstruct GMap into a list of GMapEntrys.

parseToGMap

Arguments

:: (IsList (c k v), Item (c k v) ~ (k, v))

=> (s -> Parser k)

key parser

-> (s -> Parser v)

value parser

-> (HashMap Text s -> Parser (c k v))

object parser

-> Either (HashMap Text s) (Vector s)

input object or flattened key-values.

-> Parser (GMap c k v)

General parser for GMap.

GMapEntry

data GMapEntry k v

Haskell representation of Map.Entry type.

Basically GraphSON encodes Java's Map.Entry type as if it were a Map with a single entry. Thus its encoded form is either a JSON object or a flattened key-values, as explained in GMap.

>>> Aeson.eitherDecode "{\"1\": \"one\"}" :: Either String (GMapEntry Int Text)
Right (GMapEntry {gmapEntryFlat = False, gmapEntryKey = 1, gmapEntryValue = "one"})
>>> Aeson.eitherDecode "[1, \"one\"]" :: Either String (GMapEntry Int Text)
Right (GMapEntry {gmapEntryFlat = True, gmapEntryKey = 1, gmapEntryValue = "one"})
>>> Aeson.encode (GMapEntry False "one" 1 :: GMapEntry Text Int)
"{\"one\":1}"
>>> Aeson.encode (GMapEntry True "one" 1 :: GMapEntry Text Int)
"[\"one\",1]"

In old versions of TinkerPop, Map.Entry is encoded as a JSON object with "key" and "value" fields. FromJSON instance of GMapEntry supports this format as well, but ToJSON instance doesn't support it.

>>> Aeson.eitherDecode "{\"key\":1, \"value\": \"one\"}" :: Either String (GMapEntry Int Text)
Right (GMapEntry {gmapEntryFlat = False, gmapEntryKey = 1, gmapEntryValue = "one"})

Constructors

GMapEntry

Fields

• gmapEntryFlat :: !Bool
• gmapEntryKey :: !k
• gmapEntryValue :: !v

Instances

Functor (GMapEntry k)

Defined in Data.Greskell.GMap

Methods

fmap :: (a -> b) -> GMapEntry k a -> GMapEntry k b

(<$) :: a -> GMapEntry k b -> GMapEntry k a

Foldable (GMapEntry k)

Defined in Data.Greskell.GMap

Methods

fold :: Monoid m => GMapEntry k m -> m

foldMap :: Monoid m => (a -> m) -> GMapEntry k a -> m

foldr :: (a -> b -> b) -> b -> GMapEntry k a -> b

foldr' :: (a -> b -> b) -> b -> GMapEntry k a -> b

foldl :: (b -> a -> b) -> b -> GMapEntry k a -> b

foldl' :: (b -> a -> b) -> b -> GMapEntry k a -> b

foldr1 :: (a -> a -> a) -> GMapEntry k a -> a

foldl1 :: (a -> a -> a) -> GMapEntry k a -> a

toList :: GMapEntry k a -> [a]

null :: GMapEntry k a -> Bool

length :: GMapEntry k a -> Int

elem :: Eq a => a -> GMapEntry k a -> Bool

maximum :: Ord a => GMapEntry k a -> a

minimum :: Ord a => GMapEntry k a -> a

sum :: Num a => GMapEntry k a -> a

product :: Num a => GMapEntry k a -> a

Traversable (GMapEntry k)

Defined in Data.Greskell.GMap

Methods

traverse :: Applicative f => (a -> f b) -> GMapEntry k a -> f (GMapEntry k b)

sequenceA :: Applicative f => GMapEntry k (f a) -> f (GMapEntry k a)

mapM :: Monad m => (a -> m b) -> GMapEntry k a -> m (GMapEntry k b)

sequence :: Monad m => GMapEntry k (m a) -> m (GMapEntry k a)

(Eq k, Eq v) => Eq (GMapEntry k v)

Defined in Data.Greskell.GMap

Methods

(==) :: GMapEntry k v -> GMapEntry k v -> Bool

(/=) :: GMapEntry k v -> GMapEntry k v -> Bool

(Ord k, Ord v) => Ord (GMapEntry k v)

Defined in Data.Greskell.GMap

Methods

compare :: GMapEntry k v -> GMapEntry k v -> Ordering

(<) :: GMapEntry k v -> GMapEntry k v -> Bool

(<=) :: GMapEntry k v -> GMapEntry k v -> Bool

(>) :: GMapEntry k v -> GMapEntry k v -> Bool

(>=) :: GMapEntry k v -> GMapEntry k v -> Bool

max :: GMapEntry k v -> GMapEntry k v -> GMapEntry k v

min :: GMapEntry k v -> GMapEntry k v -> GMapEntry k v

(Show k, Show v) => Show (GMapEntry k v)

Defined in Data.Greskell.GMap

Methods

showsPrec :: Int -> GMapEntry k v -> ShowS

show :: GMapEntry k v -> String

showList :: [GMapEntry k v] -> ShowS

(ToJSON k, ToJSONKey k, Ord k, ToJSON v) => ToJSON (GMapEntry k v)

Defined in Data.Greskell.GMap

Methods

toJSON :: GMapEntry k v -> Value

toEncoding :: GMapEntry k v -> Encoding

toJSONList :: [GMapEntry k v] -> Value

toEncodingList :: [GMapEntry k v] -> Encoding

(FromJSON k, FromJSONKey k, FromJSON v) => FromJSON (GMapEntry k v)

Use parseToGMapEntry.

Defined in Data.Greskell.GMap

Methods

parseJSON :: Value -> Parser (GMapEntry k v)

parseJSONList :: Value -> Parser [GMapEntry k v]

GraphSONTyped (GMapEntry k v)

Map to "g:Map".

Defined in Data.Greskell.GMap

Methods

gsonTypeFor :: GMapEntry k v -> Text

(FromGraphSON k, FromGraphSON v, FromJSONKey k) => FromGraphSON (GMapEntry k v)

Use parseToGMapEntry.

Defined in Data.Greskell.GraphSON

Methods

parseGraphSON :: GValue -> Parser (GMapEntry k v)

AsIterator (GMapEntry k v)

Defined in Data.Greskell.AsIterator

Associated Types

type IteratorItem (GMapEntry k v) :: Type

type IteratorItem (GMapEntry k v)

Defined in Data.Greskell.AsIterator

type IteratorItem (GMapEntry k v) = GMapEntry k v

unGMapEntry :: GMapEntry k v -> (k, v)

Get the key-value pair from GMapEntry.

parseToGMapEntry

Arguments

:: FromJSONKey k

=> (s -> Parser k)

key parser

-> (s -> Parser v)

value parser

-> Either (HashMap Text s) (Vector s)

input object or flattened key-values

-> Parser (GMapEntry k v)

General parser for GMapEntry.