Data.Greskell.GraphSON

GraphSON

data GraphSON v

Wrapper for "typed JSON object" introduced in GraphSON version 2. See http://tinkerpop.apache.org/docs/current/dev/io/#graphson

This data type is useful for encoding/decoding GraphSON text.

>>> Aeson.decode "1000" :: Maybe (GraphSON Int32)
Just (GraphSON {gsonType = Nothing, gsonValue = 1000})
>>> Aeson.decode "{\"@type\": \"g:Int32\", \"@value\": 1000}" :: Maybe (GraphSON Int32)
Just (GraphSON {gsonType = Just "g:Int32", gsonValue = 1000})

Note that encoding of the "g:Map" type is inconsistent between GraphSON v1 and v2, v3. To handle the encoding, use Data.Greskell.GMap.

Constructors

GraphSON

Fields

• gsonType :: Maybe Text

  Type ID, corresponding to @type field.

• gsonValue :: v

  Value, correspoding to @value field.

Instances

Functor GraphSON

Methods

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

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

Foldable GraphSON

Methods

fold :: Monoid m => GraphSON m -> m

foldMap :: Monoid m => (a -> m) -> GraphSON a -> m

foldr :: (a -> b -> b) -> b -> GraphSON a -> b

foldr' :: (a -> b -> b) -> b -> GraphSON a -> b

foldl :: (b -> a -> b) -> b -> GraphSON a -> b

foldl' :: (b -> a -> b) -> b -> GraphSON a -> b

foldr1 :: (a -> a -> a) -> GraphSON a -> a

foldl1 :: (a -> a -> a) -> GraphSON a -> a

toList :: GraphSON a -> [a]

null :: GraphSON a -> Bool

length :: GraphSON a -> Int

elem :: Eq a => a -> GraphSON a -> Bool

maximum :: Ord a => GraphSON a -> a

minimum :: Ord a => GraphSON a -> a

sum :: Num a => GraphSON a -> a

product :: Num a => GraphSON a -> a

Traversable GraphSON

Methods

traverse :: Applicative f => (a -> f b) -> GraphSON a -> f (GraphSON b)

sequenceA :: Applicative f => GraphSON (f a) -> f (GraphSON a)

mapM :: Monad m => (a -> m b) -> GraphSON a -> m (GraphSON b)

sequence :: Monad m => GraphSON (m a) -> m (GraphSON a)

Eq v => Eq (GraphSON v)

Methods

(==) :: GraphSON v -> GraphSON v -> Bool

(/=) :: GraphSON v -> GraphSON v -> Bool

Ord v => Ord (GraphSON v)

Methods

compare :: GraphSON v -> GraphSON v -> Ordering

(<) :: GraphSON v -> GraphSON v -> Bool

(<=) :: GraphSON v -> GraphSON v -> Bool

(>) :: GraphSON v -> GraphSON v -> Bool

(>=) :: GraphSON v -> GraphSON v -> Bool

max :: GraphSON v -> GraphSON v -> GraphSON v

min :: GraphSON v -> GraphSON v -> GraphSON v

Show v => Show (GraphSON v)

Methods

showsPrec :: Int -> GraphSON v -> ShowS

show :: GraphSON v -> String

showList :: [GraphSON v] -> ShowS

Generic (GraphSON v)

Associated Types

type Rep (GraphSON v) :: * -> *

Methods

from :: GraphSON v -> Rep (GraphSON v) x

to :: Rep (GraphSON v) x -> GraphSON v

Hashable v => Hashable (GraphSON v)

Since: 0.1.2.0

Methods

hashWithSalt :: Int -> GraphSON v -> Int

hash :: GraphSON v -> Int

ToJSON v => ToJSON (GraphSON v)

If gsonType is Just, the GraphSON is encoded as a typed JSON object. If gsonType is Nothing, the gsonValue is directly encoded.

Methods

toJSON :: GraphSON v -> Value

toEncoding :: GraphSON v -> Encoding

toJSONList :: [GraphSON v] -> Value

toEncodingList :: [GraphSON v] -> Encoding

FromJSON v => FromJSON (GraphSON v)

If the given Value is a typed JSON object, gsonType field of the result is Just. Otherwise, the given Value is directly parsed into gsonValue, and gsonType is Nothing.

Methods

parseJSON :: Value -> Parser (GraphSON v)

parseJSONList :: Value -> Parser [GraphSON v]

type Rep (GraphSON v)

type Rep (GraphSON v) = D1 * (MetaData "GraphSON" "Data.Greskell.GraphSON.Core" "greskell-core-0.1.2.0-HrobBCKEhQy2PrcN852fWr" False) (C1 * (MetaCons "GraphSON" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "gsonType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Text))) (S1 * (MetaSel (Just Symbol "gsonValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * v))))

class GraphSONTyped a where

Types that have an intrinsic type ID for gsonType field.

Minimal complete definition

gsonTypeFor

Methods

gsonTypeFor :: a -> Text

Type ID for gsonType.

Instances

GraphSONTyped Char

Methods

gsonTypeFor :: Char -> Text

GraphSONTyped Double

Methods

gsonTypeFor :: Double -> Text

GraphSONTyped Float

Methods

gsonTypeFor :: Float -> Text

GraphSONTyped Int8

Map to "gx:Byte". Note that Java's Byte is signed.

Methods

gsonTypeFor :: Int8 -> Text

GraphSONTyped Int16

Methods

gsonTypeFor :: Int16 -> Text

GraphSONTyped Int32

Methods

gsonTypeFor :: Int32 -> Text

GraphSONTyped Int64

Methods

gsonTypeFor :: Int64 -> Text

GraphSONTyped Scientific

Map to "g:Double".

Methods

gsonTypeFor :: Scientific -> Text

GraphSONTyped IntSet

Since: 0.1.2.0

Methods

gsonTypeFor :: IntSet -> Text

GraphSONTyped [a]

Methods

gsonTypeFor :: [a] -> Text

GraphSONTyped (IntMap v)

Since: 0.1.2.0

Methods

gsonTypeFor :: IntMap v -> Text

GraphSONTyped (Seq a)

Since: 0.1.2.0

Methods

gsonTypeFor :: Seq a -> Text

GraphSONTyped (Set a)

Since: 0.1.2.0

Methods

gsonTypeFor :: Set a -> Text

GraphSONTyped (HashSet a)

Methods

gsonTypeFor :: HashSet a -> Text

GraphSONTyped (Vector a)

Since: 0.1.2.0

Methods

gsonTypeFor :: Vector a -> Text

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

Since: 0.1.2.0

Methods

gsonTypeFor :: Either a b -> Text

GraphSONTyped (HashMap k v)

Methods

gsonTypeFor :: HashMap k v -> Text

GraphSONTyped (Map k v)

Since: 0.1.2.0

Methods

gsonTypeFor :: Map k v -> Text

GraphSONTyped (GMapEntry k v)

Map to "g:Map".

Methods

gsonTypeFor :: GMapEntry k v -> Text

GraphSONTyped (GMap c k v)

Map to "g:Map".

Methods

gsonTypeFor :: GMap c k v -> Text

GraphSONTyped (FlattenedMap c k v)

Map to "g:Map".

Methods

gsonTypeFor :: FlattenedMap c k v -> Text

constructors

nonTypedGraphSON :: v -> GraphSON v

Create a GraphSON without gsonType.

>>> nonTypedGraphSON (10 :: Int)
GraphSON {gsonType = Nothing, gsonValue = 10}

typedGraphSON :: GraphSONTyped v => v -> GraphSON v

Create a GraphSON with its type ID.

>>> typedGraphSON (10 :: Int32)
GraphSON {gsonType = Just "g:Int32", gsonValue = 10}

typedGraphSON' :: Text -> v -> GraphSON v

Create a GraphSON with the given type ID.

>>> typedGraphSON' "g:Int32" (10 :: Int)
GraphSON {gsonType = Just "g:Int32", gsonValue = 10}

parser support

parseTypedGraphSON :: (GraphSONTyped v, FromJSON v) => Value -> Parser (GraphSON v)

Parse GraphSON v, but it checks gsonType. If gsonType is Nothing or it's not equal to gsonTypeFor, the Parser fails.

GValue

data GValue

An Aeson Value wrapped in GraphSON wrapper type. Basically this type is the Haskell representaiton of a GraphSON-encoded document.

This type is used to parse GraphSON documents. See also FromGraphSON class.

Since: 0.1.2.0

Instances

Eq GValue

Methods

(==) :: GValue -> GValue -> Bool

(/=) :: GValue -> GValue -> Bool

Show GValue

Methods

showsPrec :: Int -> GValue -> ShowS

show :: GValue -> String

showList :: [GValue] -> ShowS

Generic GValue

Associated Types

type Rep GValue :: * -> *

Methods

from :: GValue -> Rep GValue x

to :: Rep GValue x -> GValue

Hashable GValue

Methods

hashWithSalt :: Int -> GValue -> Int

hash :: GValue -> Int

ToJSON GValue

Reconstruct Value from GValue. It preserves all GraphSON wrappers.

Methods

toJSON :: GValue -> Value

toEncoding :: GValue -> Encoding

toJSONList :: [GValue] -> Value

toEncodingList :: [GValue] -> Encoding

FromJSON GValue

Parse GraphSON wrappers recursively in Value, making it into GValue.

Methods

parseJSON :: Value -> Parser GValue

parseJSONList :: Value -> Parser [GValue]

FromGraphSON GValue

Methods

parseGraphSON :: GValue -> Parser GValue

type Rep GValue

type Rep GValue = D1 * (MetaData "GValue" "Data.Greskell.GraphSON.GValue" "greskell-core-0.1.2.0-HrobBCKEhQy2PrcN852fWr" True) (C1 * (MetaCons "GValue" PrefixI True) (S1 * (MetaSel (Just Symbol "unGValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (GraphSON GValueBody))))

data GValueBody

GValue without the top-level GraphSON wrapper.

Since: 0.1.2.0

Constructors

GObject !(HashMap Text GValue)

GArray !(Vector GValue)

GString !Text

GNumber !Scientific

GBool !Bool

GNull

Instances

Eq GValueBody

Methods

(==) :: GValueBody -> GValueBody -> Bool

(/=) :: GValueBody -> GValueBody -> Bool

Show GValueBody

Methods

showsPrec :: Int -> GValueBody -> ShowS

show :: GValueBody -> String

showList :: [GValueBody] -> ShowS

Generic GValueBody

Associated Types

type Rep GValueBody :: * -> *

Methods

from :: GValueBody -> Rep GValueBody x

to :: Rep GValueBody x -> GValueBody

Hashable GValueBody

Methods

hashWithSalt :: Int -> GValueBody -> Int

hash :: GValueBody -> Int

ToJSON GValueBody

Methods

toJSON :: GValueBody -> Value

toEncoding :: GValueBody -> Encoding

toJSONList :: [GValueBody] -> Value

toEncodingList :: [GValueBody] -> Encoding

type Rep GValueBody

type Rep GValueBody = D1 * (MetaData "GValueBody" "Data.Greskell.GraphSON.GValue" "greskell-core-0.1.2.0-HrobBCKEhQy2PrcN852fWr" False) ((:+:) * ((:+:) * (C1 * (MetaCons "GObject" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (HashMap Text GValue)))) ((:+:) * (C1 * (MetaCons "GArray" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Vector GValue)))) (C1 * (MetaCons "GString" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Text))))) ((:+:) * (C1 * (MetaCons "GNumber" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Scientific))) ((:+:) * (C1 * (MetaCons "GBool" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Bool))) (C1 * (MetaCons "GNull" PrefixI False) (U1 *)))))

constructors

nonTypedGValue :: GValueBody -> GValue

Create a GValue without "@type" field.

Since: 0.1.2.0

typedGValue'

Arguments

:: Text

"@type" field.

-> GValueBody

-> GValue

Create a GValue with the given "@type" field.

Since: 0.1.2.0

FromGraphSON

class FromGraphSON a where

Types that can be constructed from GValue. This is analogous to FromJSON class.

Instances of basic types are implemented based on the following rule.

• Simple scalar types (e.g. Int and Text): use parseUnwrapAll.
• List-like types (e.g. [], Vector and Set): use parseUnwrapList.
• Map-like types (e.g. HashMap and Map): parse into GMap first, then unwrap the GMap wrapper. That way, all versions of GraphSON formats are handled properly.
• Other types: see the individual instance documentation.

Note that Char does not have FromGraphSON instance. This is intentional. As stated in the document of AsIterator, using String in greskell is an error in most cases. To prevent you from using String, Char (and thus String) don't have FromGraphSON instances.

Since: 0.1.2.0

Minimal complete definition

parseGraphSON

Methods

parseGraphSON :: GValue -> Parser a

Instances

FromGraphSON Bool

Methods

parseGraphSON :: GValue -> Parser Bool

FromGraphSON Double

Methods

parseGraphSON :: GValue -> Parser Double

FromGraphSON Float

Methods

parseGraphSON :: GValue -> Parser Float

FromGraphSON Int

Methods

parseGraphSON :: GValue -> Parser Int

FromGraphSON Int8

Methods

parseGraphSON :: GValue -> Parser Int8

FromGraphSON Int16

Methods

parseGraphSON :: GValue -> Parser Int16

FromGraphSON Int32

Methods

parseGraphSON :: GValue -> Parser Int32

FromGraphSON Int64

Methods

parseGraphSON :: GValue -> Parser Int64

FromGraphSON Integer

Methods

parseGraphSON :: GValue -> Parser Integer

FromGraphSON Natural

Methods

parseGraphSON :: GValue -> Parser Natural

FromGraphSON Word

Methods

parseGraphSON :: GValue -> Parser Word

FromGraphSON Word8

Methods

parseGraphSON :: GValue -> Parser Word8

FromGraphSON Word16

Methods

parseGraphSON :: GValue -> Parser Word16

FromGraphSON Word32

Methods

parseGraphSON :: GValue -> Parser Word32

FromGraphSON Word64

Methods

parseGraphSON :: GValue -> Parser Word64

FromGraphSON ()

For any input GValue, parseGraphSON returns (). For example, you can use it to ignore data you get from the Gremlin server.

Methods

parseGraphSON :: GValue -> Parser ()

FromGraphSON Scientific

Methods

parseGraphSON :: GValue -> Parser Scientific

FromGraphSON Text

Methods

parseGraphSON :: GValue -> Parser Text

FromGraphSON Value

Call unwrapAll to remove all GraphSON wrappers.

Methods

parseGraphSON :: GValue -> Parser Value

FromGraphSON Text

Methods

parseGraphSON :: GValue -> Parser Text

FromGraphSON IntSet

Methods

parseGraphSON :: GValue -> Parser IntSet

FromGraphSON UUID

Methods

parseGraphSON :: GValue -> Parser UUID

FromGraphSON GValue

Methods

parseGraphSON :: GValue -> Parser GValue

FromGraphSON a => FromGraphSON [a]

Methods

parseGraphSON :: GValue -> Parser [a]

FromGraphSON a => FromGraphSON (Maybe a)

Parse GNull into Nothing.

Methods

parseGraphSON :: GValue -> Parser (Maybe a)

(FromJSON a, Integral a) => FromGraphSON (Ratio a)

Methods

parseGraphSON :: GValue -> Parser (Ratio a)

FromGraphSON v => FromGraphSON (IntMap v)

Methods

parseGraphSON :: GValue -> Parser (IntMap v)

FromGraphSON a => FromGraphSON (Seq a)

Methods

parseGraphSON :: GValue -> Parser (Seq a)

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

Methods

parseGraphSON :: GValue -> Parser (Set a)

(FromGraphSON a, Eq a, Hashable a) => FromGraphSON (HashSet a)

Methods

parseGraphSON :: GValue -> Parser (HashSet a)

FromGraphSON a => FromGraphSON (Vector a)

Methods

parseGraphSON :: GValue -> Parser (Vector a)

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

Try Left, then Right.

Methods

parseGraphSON :: GValue -> Parser (Either a b)

(FromGraphSON v, Eq k, Hashable k, FromJSONKey k, FromGraphSON k) => FromGraphSON (HashMap k v)

Methods

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

(FromGraphSON v, Ord k, FromJSONKey k, FromGraphSON k) => FromGraphSON (Map k v)

Methods

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

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

Use parseToGMapEntry.

Methods

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

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

Methods

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

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

Use parseToFlattenedMap.

Methods

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

parser support

data Parser a :: * -> *

A JSON parser.

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

MonadFail Parser

Methods

fail :: String -> Parser a

Applicative Parser

Methods

pure :: a -> Parser a

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

liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c

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

Semigroup (Parser a)

Methods

(<>) :: Parser a -> Parser a -> Parser a

sconcat :: NonEmpty (Parser a) -> Parser a

stimes :: Integral b => b -> Parser a -> Parser a

Monoid (Parser a)

Methods

mempty :: Parser a

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

mconcat :: [Parser a] -> Parser a

parseEither :: FromGraphSON a => GValue -> Either String a

Parse GValue into FromGraphSON.

Since: 0.1.2.0

parseUnwrapAll :: FromJSON a => GValue -> Parser a

Unwrap the given GValue with unwrapAll, and just parse the result with parseJSON.

Useful to implement FromGraphSON instances for scalar types.

Since: 0.1.2.0

parseUnwrapList :: (IsList a, i ~ Item a, FromGraphSON i) => GValue -> Parser a

Extract GArray from the given GValue, parse the items in the array, and gather them by fromList.

Useful to implement FromGraphSON instances for IsList types.

Since: 0.1.2.0

(.:) :: FromGraphSON a => HashMap Text GValue -> Text -> Parser a

Like Aeson's .:, but for FromGraphSON.

Since: 0.1.2.0

parseJSONViaGValue :: FromGraphSON a => Value -> Parser a

Implementation of parseJSON based on parseGraphSON. The input Value is first converted to GValue, and it's parsed to the output type.

Since: 0.1.2.0