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.

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.

Concrete data types

Concrete data types based on aeson Values.

Element IDs and property values are all Value, because they are highly polymorphic. They are wrapped with GraphSON, so that you can inspect gsonType field if present. ElementID and EdgeVertexID are bare Value type for convenience.

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.

data AVertex

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

Constructors

AVertex

Fields

• avId :: GraphSON Value

  ID of this vertex

• avLabel :: Text

  Label of this vertex

• avProperties :: PropertyMapList AVertexProperty (GraphSON Value)

  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]

GraphSONTyped AVertex

Methods

gsonTypeFor :: AVertex -> Text

Vertex AVertex

Element AVertex

Associated Types

type ElementID AVertex :: *

type ElementProperty AVertex :: * -> *

type ElementID AVertex

type ElementID AVertex = Value

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 :: GraphSON Value

  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 :: GraphSON Value

  ID of this edge's destination vertex.

• aeOutV :: GraphSON Value

  ID of this edge's source vertex.

• aeProperties :: PropertyMapSingle AProperty (GraphSON Value)

  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]

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 = Value

type ElementID AEdge

type ElementID AEdge = Value

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.

Constructors

AVertexProperty

Fields

• avpId :: GraphSON Value

  ID of this vertex property.

• avpLabel :: Text

  Label and key of this vertex property.

• avpValue :: v

  Value of this vertex property.

• avpProperties :: PropertyMapSingle AProperty (GraphSON Value)

  (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

FromJSON v => FromJSON (AVertexProperty v)

Methods

parseJSON :: Value -> Parser (AVertexProperty v)

parseJSONList :: Value -> Parser [AVertexProperty v]

GraphSONTyped (AVertexProperty v)

Methods

gsonTypeFor :: AVertexProperty v -> Text

FromJSON v => FromJSONWithKey (AVertexProperty v)

Methods

parseJSONWithKey :: Text -> Value -> Parser (AVertexProperty v)

Element (AVertexProperty v)

Associated Types

type ElementID (AVertexProperty v) :: *

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

type ElementID (AVertexProperty v)

type ElementID (AVertexProperty v) = Value

type ElementProperty (AVertexProperty v)

type ElementProperty (AVertexProperty v) = AProperty

Property

data AProperty v

General simple property type you can use for Property class.

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

FromJSON v => FromJSON (AProperty v)

Parse Property of GraphSON 1.0.

Methods

parseJSON :: Value -> Parser (AProperty v)

parseJSONList :: Value -> Parser [AProperty v]

GraphSONTyped (AProperty v)

Methods

gsonTypeFor :: AProperty v -> Text

FromJSON v => FromJSONWithKey (AProperty v)

Methods

parseJSONWithKey :: Text -> Value -> 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

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), FromJSON (p v), FromJSONWithKey (p v)) => FromJSON (PropertyMapSingle p v)

Methods

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

parseJSONList :: Value -> 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

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), FromJSON (p v), FromJSONWithKey (p v)) => FromJSON (PropertyMapList p v)

Methods

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

parseJSONList :: Value -> 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, FromJSON v) => Text -> m p (GraphSON Value) -> Parser v

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

parseListValues :: (PropertyMap m, Property p, FromJSON v) => Text -> m p (GraphSON Value) -> Parser [v]

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

parseNonEmptyValues :: (PropertyMap m, Property p, FromJSON v) => Text -> m p (GraphSON Value) -> Parser (NonEmpty v)

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

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

Create a PropertyMap from list of Propertys.

Internal use

class FromJSONWithKey a

This typeclass is for internal use.

JSON parser with a property key given from outside.

Minimal complete definition

parseJSONWithKey

Instances

FromJSON v => FromJSONWithKey (AVertexProperty v)

Methods

parseJSONWithKey :: Text -> Value -> Parser (AVertexProperty v)

FromJSON v => FromJSONWithKey (AProperty v)

Methods

parseJSONWithKey :: Text -> Value -> Parser (AProperty v)