Data.Greskell.Graph

This module defines types and functions about TinkerPop graph structure API.

TinkerPop graph structure types

class Element e

org.apache.tinkerpop.gremlin.structure.Element interface in a TinkerPop graph.

Associated Types

type ElementID e

ID type of the Element. This depends on graph database implementation and its settings.

type ElementProperty e :: * -> *

Property type of the Element. It should be of Property class. If you don't care, use AVertexProperty if type e is an Vertex and use AProperty if type e is an Edge or VertexProperty.

Instances

Element AEdge

Associated Types

type ElementID AEdge :: *

type ElementProperty AEdge :: * -> *

Element AVertex

Associated Types

type ElementID AVertex :: *

type ElementProperty AVertex :: * -> *

Element (AVertexProperty v)

Associated Types

type ElementID (AVertexProperty v) :: *

type ElementProperty (AVertexProperty v) :: * -> *

class Element v => Vertex v

org.apache.tinkerpop.gremlin.structure.Vertex interface in a TinkerPop graph.

Instances

Vertex AVertex

class Element e => Edge e

org.apache.tinkerpop.gremlin.structure.Edge interface in a TinkerPop graph.

Associated Types

type EdgeVertexID e

ID type of the Vertex this edge connects.

Instances

Edge AEdge

Associated Types

type EdgeVertexID AEdge :: *

class Property p where

org.apache.tinkerpop.gremlin.structure.Property interface in a TinkerPop graph.

Minimal complete definition

propertyKey, propertyValue

Methods

propertyKey :: p v -> Text

Get key of this property.

propertyValue :: p v -> v

Get value of this property.

Instances

Property AVertexProperty

Methods

propertyKey :: AVertexProperty v -> Text

propertyValue :: AVertexProperty v -> v

Property AProperty

Methods

propertyKey :: AProperty v -> Text

propertyValue :: AProperty v -> v

T Enum

data T a b

org.apache.tinkerpop.gremlin.structure.T enum.

T is a token to get data b from an Element a.

Instances

ProjectionLike (Greskell (T s e))

Associated Types

type ProjectionLikeStart (Greskell (T s e)) :: *

type ProjectionLikeEnd (Greskell (T s e)) :: *

GraphSONTyped (T a b)

Methods

gsonTypeFor :: T a b -> Text

type ProjectionLikeStart (Greskell (T s e))

type ProjectionLikeStart (Greskell (T s e)) = s

type ProjectionLikeEnd (Greskell (T s e))

type ProjectionLikeEnd (Greskell (T s e)) = e

tId :: Element a => Greskell (T a (ElementID a))

T.id token.

tKey :: (Element (p v), Property p) => Greskell (T (p v) Text)

T.key token.

tLabel :: Element a => Greskell (T a Text)

T.label token.

tValue :: (Element (p v), Property p) => Greskell (T (p v) v)

T.value token.

Cardinality Enum

data Cardinality

org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality enum.

Since: 0.2.0.0

cList :: Greskell Cardinality

list Cardinality.

>>> toGremlin cList
"list"

Since: 0.2.0.0

cSet :: Greskell Cardinality

set Cardinality.

Since: 0.2.0.0

cSingle :: Greskell Cardinality

single Cardinality.

Since: 0.2.0.0

Typed Key (accessor of a Property)

newtype Key a b

A property key accessing value b in an Element a. In Gremlin, it's just a String type.

Constructors

Key

Fields

• unKey :: Greskell Text

Instances

Functor (Key a)

Unsafely convert the value type b.

Methods

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

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

Eq (Key a b)

Methods

(==) :: Key a b -> Key a b -> Bool

(/=) :: Key a b -> Key a b -> Bool

Show (Key a b)

Methods

showsPrec :: Int -> Key a b -> ShowS

show :: Key a b -> String

showList :: [Key a b] -> ShowS

IsString (Key a b)

Gremlin String literal as a Key.

Methods

fromString :: String -> Key a b

ToGreskell (Key a b)

Unwrap Key constructor.

Associated Types

type GreskellReturn (Key a b) :: *

Methods

toGreskell :: Key a b -> Greskell (GreskellReturn (Key a b))

ProjectionLike (Key s e)

Associated Types

type ProjectionLikeStart (Key s e) :: *

type ProjectionLikeEnd (Key s e) :: *

type GreskellReturn (Key a b)

type GreskellReturn (Key a b) = Text

type ProjectionLikeStart (Key s e)

type ProjectionLikeStart (Key s e) = s

type ProjectionLikeEnd (Key s e)

type ProjectionLikeEnd (Key s e) = e

key :: Text -> Key a b

Create a Key from a literal string.

key-value pair

data KeyValue a where

Pair of Key and its value.

Type a is the type of Element that keeps the KeyValue pair. It drops the type of the value, so that you can construct a heterogeneous list of key-value pairs for a given Element.

Since: 0.2.0.0

Constructors

KeyValue :: Key a b -> Greskell b -> KeyValue a

(=:) :: Key a b -> Greskell b -> KeyValue a

Constructor operator of KeyValue.

Since: 0.2.0.0

Concrete data types

Concrete data types based on Aeson data types.

Element IDs and property values are all GValue, because they are highly polymorphic. ElementID and EdgeVertexID are GValue, too.

As for properties, you can use PropertyMap and other type-classes to manipulate them.

If you want to define your own graph structure types, see README.md for detail. Basically you can use FromGraphSON instances of these concrete data types to implement parsers for your own types.

NOTE: In version 0.1.1.0 and before, these conrete data types were based on GraphSON Value. In version 0.2.0.0, this was changed to GValue, so that it can parse nested data structures encoded in GraphSON.

Vertex

data AVertex

General vertex type you can use for Vertex class, based on Aeson data types.

Constructors

AVertex

Fields

• avId :: GValue

  ID of this vertex

• avLabel :: Text

  Label of this vertex

• avProperties :: PropertyMapList AVertexProperty GValue

  Properties of this vertex.

Instances

Eq AVertex

Methods

(==) :: AVertex -> AVertex -> Bool

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

Show AVertex

Methods

showsPrec :: Int -> AVertex -> ShowS

show :: AVertex -> String

showList :: [AVertex] -> ShowS

FromJSON AVertex

Methods

parseJSON :: Value -> Parser AVertex

parseJSONList :: Value -> Parser [AVertex]

FromGraphSON AVertex

Methods

parseGraphSON :: GValue -> Parser AVertex

GraphSONTyped AVertex

Methods

gsonTypeFor :: AVertex -> Text

Vertex AVertex

Element AVertex

Associated Types

type ElementID AVertex :: *

type ElementProperty AVertex :: * -> *

type ElementID AVertex

type ElementID AVertex = GValue

type ElementProperty AVertex

type ElementProperty AVertex = AVertexProperty

Edge

data AEdge

General edge type you can use for Edge class, based on Aeson data types.

Constructors

AEdge

Fields

• aeId :: GValue

  ID of this edge.

• aeLabel :: Text

  Label of this edge.

• aeInVLabel :: Text

  Label of this edge's destination vertex.

• aeOutVLabel :: Text

  Label of this edge's source vertex.

• aeInV :: GValue

  ID of this edge's destination vertex.

• aeOutV :: GValue

  ID of this edge's source vertex.

• aeProperties :: PropertyMapSingle AProperty GValue

  Properties of this edge.

Instances

Eq AEdge

Methods

(==) :: AEdge -> AEdge -> Bool

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

Show AEdge

Methods

showsPrec :: Int -> AEdge -> ShowS

show :: AEdge -> String

showList :: [AEdge] -> ShowS

FromJSON AEdge

Methods

parseJSON :: Value -> Parser AEdge

parseJSONList :: Value -> Parser [AEdge]

FromGraphSON AEdge

Methods

parseGraphSON :: GValue -> Parser AEdge

GraphSONTyped AEdge

Methods

gsonTypeFor :: AEdge -> Text

Edge AEdge

Associated Types

type EdgeVertexID AEdge :: *

Element AEdge

Associated Types

type ElementID AEdge :: *

type ElementProperty AEdge :: * -> *

type EdgeVertexID AEdge

type EdgeVertexID AEdge = GValue

type ElementID AEdge

type ElementID AEdge = GValue

type ElementProperty AEdge

type ElementProperty AEdge = AProperty

VertexProperty

data AVertexProperty v

General vertex property type you can use for VertexProperty, based on Aeson data types.

If you are not sure about the type v, just use GValue.

Constructors

AVertexProperty

Fields

• avpId :: GValue

  ID of this vertex property.

• avpLabel :: Text

  Label and key of this vertex property.

• avpValue :: v

  Value of this vertex property.

• avpProperties :: PropertyMapSingle AProperty GValue

  (meta)properties of this vertex property.

Instances

Functor AVertexProperty

Methods

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

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

Foldable AVertexProperty

Methods

fold :: Monoid m => AVertexProperty m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> AVertexProperty a -> a

foldl1 :: (a -> a -> a) -> AVertexProperty a -> a

toList :: AVertexProperty a -> [a]

null :: AVertexProperty a -> Bool

length :: AVertexProperty a -> Int

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

maximum :: Ord a => AVertexProperty a -> a

minimum :: Ord a => AVertexProperty a -> a

sum :: Num a => AVertexProperty a -> a

product :: Num a => AVertexProperty a -> a

Traversable AVertexProperty

Methods

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

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

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

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

Property AVertexProperty

Methods

propertyKey :: AVertexProperty v -> Text

propertyValue :: AVertexProperty v -> v

Eq v => Eq (AVertexProperty v)

Methods

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

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

Show v => Show (AVertexProperty v)

Methods

showsPrec :: Int -> AVertexProperty v -> ShowS

show :: AVertexProperty v -> String

showList :: [AVertexProperty v] -> ShowS

FromGraphSON v => FromJSON (AVertexProperty v)

In version 0.1.1.0 and before, the constraint was FromJSON v. This has changed.

Methods

parseJSON :: Value -> Parser (AVertexProperty v)

parseJSONList :: Value -> Parser [AVertexProperty v]

FromGraphSON v => FromGraphSON (AVertexProperty v)

Methods

parseGraphSON :: GValue -> Parser (AVertexProperty v)

GraphSONTyped (AVertexProperty v)

Methods

gsonTypeFor :: AVertexProperty v -> Text

FromGraphSON v => FromGraphSONWithKey (AVertexProperty v)

Methods

parseGraphSONWithKey :: Text -> GValue -> Parser (AVertexProperty v)

Element (AVertexProperty v)

Associated Types

type ElementID (AVertexProperty v) :: *

type ElementProperty (AVertexProperty v) :: * -> *

type ElementID (AVertexProperty v)

type ElementID (AVertexProperty v) = GValue

type ElementProperty (AVertexProperty v)

type ElementProperty (AVertexProperty v) = AProperty

Property

data AProperty v

General simple property type you can use for Property class.

If you are not sure about the type v, just use GValue.

Constructors

AProperty

Fields

• apKey :: Text
• apValue :: v

Instances

Functor AProperty

Methods

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

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

Foldable AProperty

Methods

fold :: Monoid m => AProperty m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> AProperty a -> a

foldl1 :: (a -> a -> a) -> AProperty a -> a

toList :: AProperty a -> [a]

null :: AProperty a -> Bool

length :: AProperty a -> Int

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

maximum :: Ord a => AProperty a -> a

minimum :: Ord a => AProperty a -> a

sum :: Num a => AProperty a -> a

product :: Num a => AProperty a -> a

Traversable AProperty

Methods

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

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

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

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

Property AProperty

Methods

propertyKey :: AProperty v -> Text

propertyValue :: AProperty v -> v

Eq v => Eq (AProperty v)

Methods

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

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

Ord v => Ord (AProperty v)

Methods

compare :: AProperty v -> AProperty v -> Ordering

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

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

(>) :: AProperty v -> AProperty v -> Bool

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

max :: AProperty v -> AProperty v -> AProperty v

min :: AProperty v -> AProperty v -> AProperty v

Show v => Show (AProperty v)

Methods

showsPrec :: Int -> AProperty v -> ShowS

show :: AProperty v -> String

showList :: [AProperty v] -> ShowS

FromGraphSON v => FromJSON (AProperty v)

Parse Property of GraphSON 1.0.

In version 0.1.1.0 and before, the constraint was FromJSON v. This has changed.

Methods

parseJSON :: Value -> Parser (AProperty v)

parseJSONList :: Value -> Parser [AProperty v]

FromGraphSON v => FromGraphSON (AProperty v)

Parse Property of GraphSON 1.0.

Methods

parseGraphSON :: GValue -> Parser (AProperty v)

GraphSONTyped (AProperty v)

Methods

gsonTypeFor :: AProperty v -> Text

FromGraphSON v => FromGraphSONWithKey (AProperty v)

Methods

parseGraphSONWithKey :: Text -> GValue -> Parser (AProperty v)

PropertyMap

class PropertyMap m where

Common basic operations supported by maps of properties.

Minimal complete definition

lookupList, putProperty, removeProperty, allProperties

Methods

lookupOne :: Text -> m p v -> Maybe (p v)

Look up a property associated with the given key.

lookupList :: Text -> m p v -> [p v]

Look up all properties associated with the given key.

putProperty :: Property p => p v -> m p v -> m p v

Put a property into the map.

removeProperty :: Text -> m p v -> m p v

Remove all properties associated with the given key.

allProperties :: m p v -> [p v]

Return all properties in the map.

Instances

PropertyMap PropertyMapList

Methods

lookupOne :: Text -> PropertyMapList p v -> Maybe (p v)

lookupList :: Text -> PropertyMapList p v -> [p v]

putProperty :: Property p => p v -> PropertyMapList p v -> PropertyMapList p v

removeProperty :: Text -> PropertyMapList p v -> PropertyMapList p v

allProperties :: PropertyMapList p v -> [p v]

PropertyMap PropertyMapSingle

Methods

lookupOne :: Text -> PropertyMapSingle p v -> Maybe (p v)

lookupList :: Text -> PropertyMapSingle p v -> [p v]

putProperty :: Property p => p v -> PropertyMapSingle p v -> PropertyMapSingle p v

removeProperty :: Text -> PropertyMapSingle p v -> PropertyMapSingle p v

allProperties :: PropertyMapSingle p v -> [p v]

data PropertyMapSingle p v

A PropertyMap that has a single value per key.

putProperty replaces the old property by the given property.

<> returns the union of the two given property maps. If the two property maps share some same keys, the value from the left map wins.

Instances

PropertyMap PropertyMapSingle

Methods

lookupOne :: Text -> PropertyMapSingle p v -> Maybe (p v)

lookupList :: Text -> PropertyMapSingle p v -> [p v]

putProperty :: Property p => p v -> PropertyMapSingle p v -> PropertyMapSingle p v

removeProperty :: Text -> PropertyMapSingle p v -> PropertyMapSingle p v

allProperties :: PropertyMapSingle p v -> [p v]

Functor p => Functor (PropertyMapSingle p)

Methods

fmap :: (a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b

(<$) :: a -> PropertyMapSingle p b -> PropertyMapSingle p a

Foldable p => Foldable (PropertyMapSingle p)

Methods

fold :: Monoid m => PropertyMapSingle p m -> m

foldMap :: Monoid m => (a -> m) -> PropertyMapSingle p a -> m

foldr :: (a -> b -> b) -> b -> PropertyMapSingle p a -> b

foldr' :: (a -> b -> b) -> b -> PropertyMapSingle p a -> b

foldl :: (b -> a -> b) -> b -> PropertyMapSingle p a -> b

foldl' :: (b -> a -> b) -> b -> PropertyMapSingle p a -> b

foldr1 :: (a -> a -> a) -> PropertyMapSingle p a -> a

foldl1 :: (a -> a -> a) -> PropertyMapSingle p a -> a

toList :: PropertyMapSingle p a -> [a]

null :: PropertyMapSingle p a -> Bool

length :: PropertyMapSingle p a -> Int

elem :: Eq a => a -> PropertyMapSingle p a -> Bool

maximum :: Ord a => PropertyMapSingle p a -> a

minimum :: Ord a => PropertyMapSingle p a -> a

sum :: Num a => PropertyMapSingle p a -> a

product :: Num a => PropertyMapSingle p a -> a

Traversable p => Traversable (PropertyMapSingle p)

Methods

traverse :: Applicative f => (a -> f b) -> PropertyMapSingle p a -> f (PropertyMapSingle p b)

sequenceA :: Applicative f => PropertyMapSingle p (f a) -> f (PropertyMapSingle p a)

mapM :: Monad m => (a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b)

sequence :: Monad m => PropertyMapSingle p (m a) -> m (PropertyMapSingle p a)

Eq (p v) => Eq (PropertyMapSingle p v)

Methods

(==) :: PropertyMapSingle p v -> PropertyMapSingle p v -> Bool

(/=) :: PropertyMapSingle p v -> PropertyMapSingle p v -> Bool

Show (p v) => Show (PropertyMapSingle p v)

Methods

showsPrec :: Int -> PropertyMapSingle p v -> ShowS

show :: PropertyMapSingle p v -> String

showList :: [PropertyMapSingle p v] -> ShowS

Semigroup (PropertyMapSingle p v)

Methods

(<>) :: PropertyMapSingle p v -> PropertyMapSingle p v -> PropertyMapSingle p v

sconcat :: NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v

stimes :: Integral b => b -> PropertyMapSingle p v -> PropertyMapSingle p v

Monoid (PropertyMapSingle p v)

Methods

mempty :: PropertyMapSingle p v

mappend :: PropertyMapSingle p v -> PropertyMapSingle p v -> PropertyMapSingle p v

mconcat :: [PropertyMapSingle p v] -> PropertyMapSingle p v

(Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v)) => FromJSON (PropertyMapSingle p v)

In version 0.1.1.0 and before, the constraint was FromJSON v. This has changed.

Methods

parseJSON :: Value -> Parser (PropertyMapSingle p v)

parseJSONList :: Value -> Parser [PropertyMapSingle p v]

(Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v)) => FromGraphSON (PropertyMapSingle p v)

Methods

parseGraphSON :: GValue -> Parser (PropertyMapSingle p v)

data PropertyMapList p v

A PropertyMap that can keep more than one values per key.

lookupOne returns the first property associated with the given key.

putProperty prepends the given property to the property list.

<> returns the union of the two given property maps. If the two property maps share some same keys, those property lists are concatenated.

Instances

PropertyMap PropertyMapList

Methods

lookupOne :: Text -> PropertyMapList p v -> Maybe (p v)

lookupList :: Text -> PropertyMapList p v -> [p v]

putProperty :: Property p => p v -> PropertyMapList p v -> PropertyMapList p v

removeProperty :: Text -> PropertyMapList p v -> PropertyMapList p v

allProperties :: PropertyMapList p v -> [p v]

Functor p => Functor (PropertyMapList p)

Methods

fmap :: (a -> b) -> PropertyMapList p a -> PropertyMapList p b

(<$) :: a -> PropertyMapList p b -> PropertyMapList p a

Foldable p => Foldable (PropertyMapList p)

Methods

fold :: Monoid m => PropertyMapList p m -> m

foldMap :: Monoid m => (a -> m) -> PropertyMapList p a -> m

foldr :: (a -> b -> b) -> b -> PropertyMapList p a -> b

foldr' :: (a -> b -> b) -> b -> PropertyMapList p a -> b

foldl :: (b -> a -> b) -> b -> PropertyMapList p a -> b

foldl' :: (b -> a -> b) -> b -> PropertyMapList p a -> b

foldr1 :: (a -> a -> a) -> PropertyMapList p a -> a

foldl1 :: (a -> a -> a) -> PropertyMapList p a -> a

toList :: PropertyMapList p a -> [a]

null :: PropertyMapList p a -> Bool

length :: PropertyMapList p a -> Int

elem :: Eq a => a -> PropertyMapList p a -> Bool

maximum :: Ord a => PropertyMapList p a -> a

minimum :: Ord a => PropertyMapList p a -> a

sum :: Num a => PropertyMapList p a -> a

product :: Num a => PropertyMapList p a -> a

Traversable p => Traversable (PropertyMapList p)

Methods

traverse :: Applicative f => (a -> f b) -> PropertyMapList p a -> f (PropertyMapList p b)

sequenceA :: Applicative f => PropertyMapList p (f a) -> f (PropertyMapList p a)

mapM :: Monad m => (a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b)

sequence :: Monad m => PropertyMapList p (m a) -> m (PropertyMapList p a)

Eq (p v) => Eq (PropertyMapList p v)

Methods

(==) :: PropertyMapList p v -> PropertyMapList p v -> Bool

(/=) :: PropertyMapList p v -> PropertyMapList p v -> Bool

Show (p v) => Show (PropertyMapList p v)

Methods

showsPrec :: Int -> PropertyMapList p v -> ShowS

show :: PropertyMapList p v -> String

showList :: [PropertyMapList p v] -> ShowS

Semigroup (PropertyMapList p v)

Methods

(<>) :: PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v

sconcat :: NonEmpty (PropertyMapList p v) -> PropertyMapList p v

stimes :: Integral b => b -> PropertyMapList p v -> PropertyMapList p v

Monoid (PropertyMapList p v)

Methods

mempty :: PropertyMapList p v

mappend :: PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v

mconcat :: [PropertyMapList p v] -> PropertyMapList p v

(Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v)) => FromJSON (PropertyMapList p v)

In version 0.1.1.0 and before, the constraint was FromJSON v. This has changed.

Methods

parseJSON :: Value -> Parser (PropertyMapList p v)

parseJSONList :: Value -> Parser [PropertyMapList p v]

(Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v)) => FromGraphSON (PropertyMapList p v)

Methods

parseGraphSON :: GValue -> Parser (PropertyMapList p v)

lookupOneValue :: (PropertyMap m, Property p) => Text -> m p v -> Maybe v

Lookup a property value from a PropertyMap by key.

lookupListValues :: (PropertyMap m, Property p) => Text -> m p v -> [v]

Lookup a list of property values from a PropertyMap by key.

parseOneValue :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser v

Lookup a property GValue by the given key, and parse it.

In version 0.1.1.0 and before, this function took an argument m p (GraphSON Value). This has changed, because property types for AVertex etc have changed.

parseListValues :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser [v]

Lookup a list of property values from a PropertyMap by the given key, and parse them.

In version 0.1.1.0 and before, this function took an argument m p (GraphSON Value). This has changed, because property types for AVertex etc have changed.

parseNonEmptyValues :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser (NonEmpty v)

Like parseListValues, but this function fails when there is no property with the given key.

In version 0.1.1.0 and before, this function took an argument m p (GraphSON Value). This has changed, because property types for AVertex etc have changed.

fromProperties :: (PropertyMap m, Property p, Monoid (m p v)) => [p v] -> m p v

Create a PropertyMap from list of Propertys.

Internal use

class FromGraphSONWithKey a

This typeclass is for internal use.

GraphSON parser with a property key given from outside.

Since: 0.2.0.0

Minimal complete definition

parseGraphSONWithKey

Instances

FromGraphSON v => FromGraphSONWithKey (AVertexProperty v)

Methods

parseGraphSONWithKey :: Text -> GValue -> Parser (AVertexProperty v)

FromGraphSON v => FromGraphSONWithKey (AProperty v)

Methods

parseGraphSONWithKey :: Text -> GValue -> Parser (AProperty v)