| Maintainer | Toshio Ito <debug.ito@gmail.com> |
|---|---|
| Safe Haskell | Safe-Inferred |
| Language | Haskell2010 |
Data.Greskell.GTraversal
Description
This module defines GTraversal, greskell counterpart of
GraphTraversal class object, and a DSL of composing graph
traversal steps.
Synopsis
- newtype GTraversal c s e = GTraversal {
- unGTraversal :: Greskell (GraphTraversal c s e)
- data GraphTraversal c s e
- class ToGTraversal g where
- toGTraversal :: WalkType c => g c s e -> GTraversal c s e
- liftWalk :: (WalkType from, WalkType to, Lift from to) => g from s e -> g to s e
- unsafeCastStart :: WalkType c => g c s1 e -> g c s2 e
- unsafeCastEnd :: WalkType c => g c s e1 -> g c s e2
- data Walk c s e
- data GraphTraversalSource
- class WalkType t
- data Filter
- data Transform
- data SideEffect
- class Lift from to
- class Split c p
- source :: Text -> Greskell GraphTraversalSource
- sV :: Vertex v => [Greskell (ElementID v)] -> Greskell GraphTraversalSource -> GTraversal Transform () v
- sV' :: [Greskell (ElementID AVertex)] -> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
- sE :: Edge e => [Greskell (ElementID e)] -> Greskell GraphTraversalSource -> GTraversal Transform () e
- sE' :: [Greskell (ElementID AEdge)] -> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
- sAddV :: Vertex v => Greskell Text -> Greskell GraphTraversalSource -> GTraversal SideEffect () v
- sAddV' :: Greskell Text -> Greskell GraphTraversalSource -> GTraversal SideEffect () AVertex
- (&.) :: GTraversal c a b -> Walk c b d -> GTraversal c a d
- ($.) :: Walk c b d -> GTraversal c a b -> GTraversal c a d
- (<$.>) :: Functor f => Walk c b d -> f (GTraversal c a b) -> f (GTraversal c a d)
- (<*.>) :: Applicative f => f (Walk c b d) -> f (GTraversal c a b) -> f (GTraversal c a d)
- gIterate :: WalkType c => GTraversal c s e -> GTraversal c s ()
- unsafeGTraversal :: Text -> GTraversal c s e
- unsafeWalk :: WalkType c => Text -> [Text] -> Walk c s e
- modulateWith :: WalkType c => Walk c s e -> [Walk c e e] -> Walk c s e
- gIdentity :: WalkType c => Walk c s s
- gIdentity' :: Walk Filter s s
- gFilter :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
- gCyclicPath :: WalkType c => Walk c a a
- gCyclicPath' :: Walk Filter a a
- gSimplePath :: WalkType c => Walk c a a
- gSimplePath' :: Walk Filter a a
- gIs :: WalkType c => Greskell v -> Walk c v v
- gIs' :: Greskell v -> Walk Filter v v
- gIsP :: WalkType c => Greskell (P v) -> Walk c v v
- gIsP' :: Greskell (P v) -> Walk Filter v v
- gHas1 :: (WalkType c, Element s) => Key s v -> Walk c s s
- gHas1' :: Element s => Key s v -> Walk Filter s s
- gHas2 :: (WalkType c, Element s) => Key s v -> Greskell v -> Walk c s s
- gHas2' :: Element s => Key s v -> Greskell v -> Walk Filter s s
- gHas2P :: (WalkType c, Element s) => Key s v -> Greskell (P v) -> Walk c s s
- gHas2P' :: Element s => Key s v -> Greskell (P v) -> Walk Filter s s
- gHasLabel :: (Element s, WalkType c) => Greskell Text -> Walk c s s
- gHasLabel' :: Element s => Greskell Text -> Walk Filter s s
- gHasLabelP :: (Element s, WalkType c) => Greskell (P Text) -> Walk c s s
- gHasLabelP' :: Element s => Greskell (P Text) -> Walk Filter s s
- gHasId :: (Element s, WalkType c) => Greskell (ElementID s) -> Walk c s s
- gHasId' :: Element s => Greskell (ElementID s) -> Walk Filter s s
- gHasIdP :: (Element s, WalkType c) => Greskell (P (ElementID s)) -> Walk c s s
- gHasIdP' :: Element s => Greskell (P (ElementID s)) -> Walk Filter s s
- gHasKey :: (Element (p v), Property p, WalkType c) => Greskell Text -> Walk c (p v) (p v)
- gHasKey' :: (Element (p v), Property p) => Greskell Text -> Walk Filter (p v) (p v)
- gHasKeyP :: (Element (p v), Property p, WalkType c) => Greskell (P Text) -> Walk c (p v) (p v)
- gHasKeyP' :: (Element (p v), Property p) => Greskell (P Text) -> Walk Filter (p v) (p v)
- gHasValue :: (Element (p v), Property p, WalkType c) => Greskell v -> Walk c (p v) (p v)
- gHasValue' :: (Element (p v), Property p) => Greskell v -> Walk Filter (p v) (p v)
- gHasValueP :: (Element (p v), Property p, WalkType c) => Greskell (P v) -> Walk c (p v) (p v)
- gHasValueP' :: (Element (p v), Property p) => Greskell (P v) -> Walk Filter (p v) (p v)
- gAnd :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s
- gOr :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s
- gNot :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
- gWhereP1 :: WalkType c => Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c a a
- gWhereP1' :: Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter a a
- gWhereP2 :: WalkType c => AsLabel a -> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c x x
- gWhereP2' :: AsLabel a -> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter x x
- gOrder :: [ByComparator s] -> Walk Transform s s
- gRange :: Greskell Int -> Greskell Int -> Walk Transform s s
- gLimit :: Greskell Int -> Walk Transform s s
- gTail :: Greskell Int -> Walk Transform s s
- gSkip :: Greskell Int -> Walk Transform s s
- gRepeat :: (ToGTraversal g, WalkType c) => Maybe RepeatLabel -> Maybe (RepeatPos, RepeatUntil c s) -> Maybe (RepeatPos, RepeatEmit c s) -> g c s s -> Walk c s s
- gTimes :: Greskell Int -> Maybe (RepeatPos, RepeatUntil c s)
- gUntilHead :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
- gUntilTail :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
- gEmitHead :: Maybe (RepeatPos, RepeatEmit c s)
- gEmitTail :: Maybe (RepeatPos, RepeatEmit c s)
- gEmitHeadT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
- gEmitTailT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
- gLoops :: Maybe RepeatLabel -> Walk Transform s Int
- data RepeatUntil c s where
- RepeatTimes :: Greskell Int -> RepeatUntil c s
- RepeatUntilT :: (WalkType cc, WalkType c, Split cc c) => GTraversal cc s e -> RepeatUntil c s
- data RepeatEmit c s where
- RepeatEmit :: RepeatEmit c s
- RepeatEmitT :: (WalkType cc, WalkType c, Split cc c) => GTraversal cc s e -> RepeatEmit c s
- data RepeatPos
- newtype RepeatLabel = RepeatLabel {}
- gLocal :: (ToGTraversal g, WalkType c) => g c s e -> Walk c s e
- gUnion :: (ToGTraversal g, WalkType c) => [g c s e] -> Walk c s e
- gCoalesce :: (ToGTraversal g, Split cc c, Lift Transform c, WalkType c, WalkType cc) => [g cc s e] -> Walk c s e
- gChoose3 :: (ToGTraversal g, Split cc c, WalkType cc, WalkType c) => g cc s ep -> g c s e -> g c s e -> Walk c s e
- gBarrier :: WalkType c => Maybe (Greskell Int) -> Walk c s s
- gDedup :: Maybe (ByProjection s e) -> Walk Transform s s
- gDedupN :: AsLabel a -> [AsLabel a] -> Maybe (ByProjection a e) -> Walk Transform s s
- gFlatMap :: (Lift Transform c, Split cc c, ToGTraversal g, WalkType c, WalkType cc) => g cc s e -> Walk c s e
- gFlatMap' :: ToGTraversal g => g Transform s e -> Walk Transform s e
- gV :: Vertex v => [Greskell (ElementID v)] -> Walk Transform s v
- gV' :: [Greskell (ElementID AVertex)] -> Walk Transform s AVertex
- gConstant :: Greskell a -> Walk Transform s a
- gProject :: LabeledByProjection s -> [LabeledByProjection s] -> Walk Transform s (PMap Single GValue)
- gAs :: AsLabel a -> Walk Transform a a
- gValues :: Element s => [Key s e] -> Walk Transform s e
- gProperties :: (Element s, Property p, ElementProperty s ~ p) => [Key s v] -> Walk Transform s (p v)
- gId :: Element s => Walk Transform s (ElementID s)
- gLabel :: Element s => Walk Transform s Text
- gValueMap :: Element s => Keys s -> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
- gElementMap :: Element s => Keys s -> Walk Transform s (PMap Single GValue)
- gSelect1 :: AsLabel a -> Walk Transform s a
- gSelectN :: AsLabel a -> AsLabel b -> [AsLabel c] -> Walk Transform s (SelectedMap GValue)
- gSelectBy1 :: AsLabel a -> ByProjection a b -> Walk Transform s b
- gSelectByN :: AsLabel a -> AsLabel a -> [AsLabel a] -> ByProjection a b -> Walk Transform s (SelectedMap b)
- gUnfold :: AsIterator a => Walk Transform a (IteratorItem a)
- gPath :: Walk Transform s (Path GValue)
- gPathBy :: ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b)
- gFold :: Walk Transform a [a]
- gCount :: Walk Transform a Int
- gOut :: (Vertex v1, Vertex v2) => [Greskell Text] -> Walk Transform v1 v2
- gOut' :: Vertex v => [Greskell Text] -> Walk Transform v AVertex
- gOutE :: (Vertex v, Edge e) => [Greskell Text] -> Walk Transform v e
- gOutE' :: Vertex v => [Greskell Text] -> Walk Transform v AEdge
- gOutV :: (Edge e, Vertex v) => Walk Transform e v
- gOutV' :: Edge e => Walk Transform e AVertex
- gIn :: (Vertex v1, Vertex v2) => [Greskell Text] -> Walk Transform v1 v2
- gIn' :: Vertex v => [Greskell Text] -> Walk Transform v AVertex
- gInE :: (Vertex v, Edge e) => [Greskell Text] -> Walk Transform v e
- gInE' :: Vertex v => [Greskell Text] -> Walk Transform v AEdge
- gInV :: (Edge e, Vertex v) => Walk Transform e v
- gInV' :: Edge e => Walk Transform e AVertex
- gMatch :: Logic MatchPattern -> Walk Transform a MatchResult
- data MatchPattern where
- MatchPattern :: AsLabel a -> Walk Transform a b -> MatchPattern
- mPattern :: (WalkType c, Lift c Transform) => AsLabel a -> Walk c a b -> Logic MatchPattern
- data MatchResult
- gSideEffect :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
- gSideEffect' :: (ToGTraversal g, WalkType c, Split c SideEffect) => g c s e -> Walk SideEffect s s
- gAddV :: Vertex v => Greskell Text -> Walk SideEffect a v
- gAddV' :: Greskell Text -> Walk SideEffect a AVertex
- gAddE :: (Vertex vs, Vertex ve, Edge e) => Greskell Text -> AddAnchor vs ve -> Walk SideEffect vs e
- gAddE' :: Greskell Text -> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge
- data AddAnchor s e
- gFrom :: ToGTraversal g => g Transform s e -> AddAnchor s e
- gTo :: ToGTraversal g => g Transform s e -> AddAnchor s e
- gDrop :: Element e => Walk SideEffect e e
- gDropP :: Property p => Walk SideEffect (p a) (p a)
- gProperty :: Element e => Key e v -> Greskell v -> Walk SideEffect e e
- gPropertyV :: (Vertex e, vp ~ ElementProperty e, Property vp, Element (vp v)) => Maybe (Greskell Cardinality) -> Key e v -> Greskell v -> [KeyValue (vp v)] -> Walk SideEffect e e
- data ByProjection s e where
- ByProjection :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
- class ProjectionLike p where
- type ProjectionLikeStart p
- type ProjectionLikeEnd p
- data ByComparator s where
- ByComparatorProj :: ByProjection s e -> ByComparator s
- ByComparatorComp :: Comparator comp => Greskell comp -> ByComparator (CompareArg comp)
- ByComparatorProjComp :: Comparator comp => ByProjection s (CompareArg comp) -> Greskell comp -> ByComparator s
- data LabeledByProjection s where
- LabeledByProjection :: AsLabel a -> ByProjection s a -> LabeledByProjection s
- gBy :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
- gBy1 :: (ProjectionLike p, ToGreskell p) => p -> ByComparator (ProjectionLikeStart p)
- gBy2 :: (ProjectionLike p, ToGreskell p, Comparator comp, ProjectionLikeEnd p ~ CompareArg comp) => p -> Greskell comp -> ByComparator (ProjectionLikeStart p)
- gByL :: (ProjectionLike p, ToGreskell p) => AsLabel (ProjectionLikeEnd p) -> p -> LabeledByProjection (ProjectionLikeStart p)
- examples :: [(Text, Text)]
- showWalkType :: WalkType t => Proxy t -> String
- showLift :: Lift from to => Proxy from -> Proxy to -> String
- showSplit :: Split c p => Proxy c -> Proxy p -> String
Types
GraphTraversal and others
newtype GTraversal c s e Source #
GraphTraversal class object of TinkerPop. It takes data s
from upstream and emits data e to downstream. Type c is called
"walk type", a marker to describe the effect of the traversal.
GTraversal is NOT a Category. Because a GraphTraversal object
keeps some context data, the starting (left-most) GraphTraversal
object controls most of the behavior of entire composition of
traversals and steps. This violates Category law.
Constructors
| GTraversal | |
Fields
| |
Instances
data GraphTraversal c s e Source #
Phantom type for GraphTraversal class. In greskell, we usually
use GTraversal instead of Greskell GraphTraversal.
Instances
class ToGTraversal g where Source #
Types that can convert to GTraversal.
Methods
toGTraversal :: WalkType c => g c s e -> GTraversal c s e Source #
liftWalk :: (WalkType from, WalkType to, Lift from to) => g from s e -> g to s e Source #
Lift WalkType from to to. Use this for type matching.
unsafeCastStart :: WalkType c => g c s1 e -> g c s2 e Source #
Unsafely cast the start type s1 into s2.
It is recommended that s2 is coercible to s1 in terms of
FromGraphSON. That is, if s2 can parse a GValue, s1
should also be able to parse that GValue.
Since: 1.0.0.0
unsafeCastEnd :: WalkType c => g c s e1 -> g c s e2 Source #
Unsafely cast the end type e1 into e2. See
unsafeCastStart.
Since: 1.0.0.0
Instances
| ToGTraversal GTraversal Source # | |
Defined in Data.Greskell.GTraversal Methods toGTraversal :: WalkType c => GTraversal c s e -> GTraversal c s e Source # liftWalk :: (WalkType from, WalkType to, Lift from to) => GTraversal from s e -> GTraversal to s e Source # unsafeCastStart :: WalkType c => GTraversal c s1 e -> GTraversal c s2 e Source # unsafeCastEnd :: WalkType c => GTraversal c s e1 -> GTraversal c s e2 Source # | |
| ToGTraversal Walk Source # | To convert a |
Defined in Data.Greskell.GTraversal Methods toGTraversal :: WalkType c => Walk c s e -> GTraversal c s e Source # liftWalk :: (WalkType from, WalkType to, Lift from to) => Walk from s e -> Walk to s e Source # unsafeCastStart :: WalkType c => Walk c s1 e -> Walk c s2 e Source # unsafeCastEnd :: WalkType c => Walk c s e1 -> Walk c s e2 Source # | |
A chain of one or more Gremlin steps. Like GTraversal, type s
is the input, type e is the output, and type c is a marker to
describe the step.
Walk represents a chain of method calls such as
.has(x).outE(). Because this is not a Gremlin (Groovy)
expression, we use bare Walk, not Greskell Walk.
Walk is a Category. You can use functions from
Control.Category to compose Walks. This is equivalent to making
a chain of method calls in Gremlin.
Walk is not an Eq, because it's difficult to define true
equality between Gremlin method calls. If we define it naively, it
might have conflict with Category law.
Instances
data GraphTraversalSource Source #
GraphTraversalSource class object of TinkerPop. It is a factory
object of GraphTraversals.
Instances
| Show GraphTraversalSource Source # | |
Defined in Data.Greskell.GTraversal Methods showsPrec :: Int -> GraphTraversalSource -> ShowS # show :: GraphTraversalSource -> String # showList :: [GraphTraversalSource] -> ShowS # | |
Walk types
Class of phantom type markers to describe the effect of the walk/traversals.
Minimal complete definition
Instances
| WalkType Filter Source # | |
Defined in Data.Greskell.GTraversal | |
| WalkType SideEffect Source # | |
Defined in Data.Greskell.GTraversal Methods showWalkType :: Proxy SideEffect -> String Source # | |
| WalkType Transform Source # | |
Defined in Data.Greskell.GTraversal | |
WalkType for filtering steps.
A filtering step is a step that does filtering only. It takes input and emits some of them without any modification, reordering, traversal actions, or side-effects. Filtering decision must be solely based on each element.
(gSideEffect w == gIdentity) AND (gFilter w == w)
If Walks w1 and w2 are Filter type, then
gAnd [w1, w2] == w1 >>> w2 == w2 >>> w1
Instances
WalkType for steps without any side-effects. This includes transformations, reordring, injections and graph traversal actions.
A Walk w is Transform type iff:
gSideEffect w == gIdentity
Instances
data SideEffect Source #
WalkType for steps that may have side-effects.
A side-effect here means manipulation of the "sideEffect" in Gremlin context (i.e. the stash of data kept in a Traversal object), as well as interaction with the world outside the Traversal object.
For example, the following steps (in Gremlin) all have side-effects.
.addE('label')
.aggregate('x')
.sideEffect(System.out.&println)
.map { some_variable += 1 }Instances
| WalkType SideEffect Source # | |
Defined in Data.Greskell.GTraversal Methods showWalkType :: Proxy SideEffect -> String Source # | |
| Lift SideEffect SideEffect Source # | |
Defined in Data.Greskell.GTraversal Methods showLift :: Proxy SideEffect -> Proxy SideEffect -> String Source # | |
| Lift Transform SideEffect Source # | |
Defined in Data.Greskell.GTraversal | |
| Split SideEffect SideEffect Source # |
|
Defined in Data.Greskell.GTraversal Methods showSplit :: Proxy SideEffect -> Proxy SideEffect -> String Source # | |
Relation of WalkTypes where one includes the other. from can
be lifted to to, because to is more powerful than from.
Minimal complete definition
Instances
| WalkType c => Lift Filter c Source # | |
| Lift SideEffect SideEffect Source # | |
Defined in Data.Greskell.GTraversal Methods showLift :: Proxy SideEffect -> Proxy SideEffect -> String Source # | |
| Lift Transform SideEffect Source # | |
Defined in Data.Greskell.GTraversal | |
| Lift Transform Transform Source # | |
Relation of WalkTypes where the child walk c is split from
the parent walk p.
When splitting, transformation effect done in the child walk is rolled back (canceled) in the parent walk.
Minimal complete definition
Instances
| WalkType p => Split Filter p Source # | |
| Split SideEffect SideEffect Source # |
|
Defined in Data.Greskell.GTraversal Methods showSplit :: Proxy SideEffect -> Proxy SideEffect -> String Source # | |
| WalkType p => Split Transform p Source # |
|
GraphTraversalSource
Arguments
| :: Text | variable name of |
| -> Greskell GraphTraversalSource |
Create GraphTraversalSource from a varible name in Gremlin
Arguments
| :: Vertex v | |
| => [Greskell (ElementID v)] | vertex IDs |
| -> Greskell GraphTraversalSource | |
| -> GTraversal Transform () v |
.V() method on GraphTraversalSource.
Arguments
| :: [Greskell (ElementID AVertex)] | vertex IDs |
| -> Greskell GraphTraversalSource | |
| -> GTraversal Transform () AVertex |
Monomorphic version of sV.
Arguments
| :: Edge e | |
| => [Greskell (ElementID e)] | edge IDs |
| -> Greskell GraphTraversalSource | |
| -> GTraversal Transform () e |
.E() method on GraphTraversalSource.
Arguments
| :: [Greskell (ElementID AEdge)] | edge IDs |
| -> Greskell GraphTraversalSource | |
| -> GTraversal Transform () AEdge |
Monomorphic version of sE.
Arguments
| :: Vertex v | |
| => Greskell Text | vertex label |
| -> Greskell GraphTraversalSource | |
| -> GTraversal SideEffect () v |
.addV() method on GraphTraversalSource.
Since: 0.2.0.0
sAddV' :: Greskell Text -> Greskell GraphTraversalSource -> GTraversal SideEffect () AVertex Source #
Monomorphic version of sAddV.
Since: 0.2.0.0
GTraversal
(&.) :: GTraversal c a b -> Walk c b d -> GTraversal c a d infixl 1 Source #
Apply the Walk to the GTraversal. In Gremlin, this means
calling a chain of methods on the Traversal object.
($.) :: Walk c b d -> GTraversal c a b -> GTraversal c a d infixr 0 Source #
Same as &. with arguments flipped.
(<$.>) :: Functor f => Walk c b d -> f (GTraversal c a b) -> f (GTraversal c a d) infixr 0 Source #
(<*.>) :: Applicative f => f (Walk c b d) -> f (GTraversal c a b) -> f (GTraversal c a d) infixr 0 Source #
gIterate :: WalkType c => GTraversal c s e -> GTraversal c s () Source #
.iterate method on GraphTraversal.
gIterate is not a Walk because it's usually used to terminate
the method chain of Gremlin steps. The returned GTraversal
outputs nothing, thus its end type is ().
Since: 1.1.0.0
unsafeGTraversal :: Text -> GTraversal c s e Source #
Unsafely create GTraversal from the given raw Gremlin script.
Walk/Steps
Functions for TinkerPop graph traversal steps. For now greskell does not cover all graph traversal steps. If you want some steps added, just open an issue.
There may be multiple versions of Haskell functions for a single step. This is because Gremlin steps are too polymorphic for Haskell. greskell should be type-safe so that incorrect combination of steps is detected in compile time. Functions for TinkerPop graph traversal steps.
Arguments
| :: WalkType c | |
| => Text | step method name (e.g. "outE") |
| -> [Text] | step method arguments |
| -> Walk c s e |
Unsafely create a Walk that represents a single method call on
a GraphTraversal.
Filter steps
gFilter :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s Source #
.filter step that takes a traversal.
gCyclicPath :: WalkType c => Walk c a a Source #
.cyclicPath step.
Since: 1.0.1.0
gCyclicPath' :: Walk Filter a a Source #
Monomorphic version of gCyclicPath.
Since: 1.0.1.0
gSimplePath :: WalkType c => Walk c a a Source #
.simplePath step.
Since: 1.0.1.0
gSimplePath' :: Walk Filter a a Source #
Monomorphic version of gSimplePath.
Since: 1.0.1.0
Is step
Has steps
.has step with one argument.
gHas2 :: (WalkType c, Element s) => Key s v -> Greskell v -> Walk c s s Source #
.has step with two arguments.
gHas2' :: Element s => Key s v -> Greskell v -> Walk Filter s s Source #
Monomorphic verson of gHas2.
Arguments
| :: (WalkType c, Element s) | |
| => Key s v | property key |
| -> Greskell (P v) | predicate on the property value |
| -> Walk c s s |
.has step with two arguments and P type.
gHas2P' :: Element s => Key s v -> Greskell (P v) -> Walk Filter s s Source #
Monomorphic version of gHas2P.
gHasLabel' :: Element s => Greskell Text -> Walk Filter s s Source #
Monomorphic version of gHasLabel.
.hasLabel step with P type. Supported since TinkerPop 3.2.7.
gHasLabelP' :: Element s => Greskell (P Text) -> Walk Filter s s Source #
Monomorphic version of gHasLabelP.
gHasId' :: Element s => Greskell (ElementID s) -> Walk Filter s s Source #
Monomorphic version of gHasId.
gHasIdP :: (Element s, WalkType c) => Greskell (P (ElementID s)) -> Walk c s s Source #
.hasId step with P type. Supported since TinkerPop 3.2.7.
gHasIdP' :: Element s => Greskell (P (ElementID s)) -> Walk Filter s s Source #
Monomorphic version of gHasIdP.
gHasKey :: (Element (p v), Property p, WalkType c) => Greskell Text -> Walk c (p v) (p v) Source #
.hasKey step. The input type should be a VertexProperty.
gHasKey' :: (Element (p v), Property p) => Greskell Text -> Walk Filter (p v) (p v) Source #
Monomorphic version of gHasKey.
Arguments
| :: (Element (p v), Property p, WalkType c) | |
| => Greskell (P Text) | predicate on the VertexProperty's key. |
| -> Walk c (p v) (p v) |
.hasKey step with P type. Supported since TinkerPop 3.2.7.
gHasKeyP' :: (Element (p v), Property p) => Greskell (P Text) -> Walk Filter (p v) (p v) Source #
Monomorphic version of gHasKeyP.
gHasValue :: (Element (p v), Property p, WalkType c) => Greskell v -> Walk c (p v) (p v) Source #
.hasValue step. The input type should be a VertexProperty.
gHasValue' :: (Element (p v), Property p) => Greskell v -> Walk Filter (p v) (p v) Source #
Monomorphic version of gHasValue.
Arguments
| :: (Element (p v), Property p, WalkType c) | |
| => Greskell (P v) | predicate on the VertexProperty's value |
| -> Walk c (p v) (p v) |
.hasValue step with P type. Supported since TinkerPop 3.2.7.
gHasValueP' :: (Element (p v), Property p) => Greskell (P v) -> Walk Filter (p v) (p v) Source #
Monomorphic version of gHasValueP.
Logic steps
gAnd :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s Source #
.and step.
gOr :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s Source #
.or step.
gNot :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s Source #
.not step.
Where step
Arguments
| :: WalkType c | |
| => Greskell (LabeledP a) | the |
| -> Maybe (ByProjection a b) | optional |
| -> Walk c a a |
.where step with P argument only.
If the ByProjection argument is Nothing, comparison is
performed on the type a. You have to ensure that the comparator
included in the LabeledP argument can handle the type
a. Usually this means the type a should implement Java's
Comparable interface (this is true for most Java classes).
If the ByProjection argument is given, comparison is performed on
the projected values of type b. So, the type b should implement
Java's Comparable interface.
Since: 1.2.0.0
gWhereP1' :: Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter a a Source #
Monomorphic version of gWhereP1.
Since: 1.2.0.0
Arguments
| :: WalkType c | |
| => AsLabel a | the starting label of |
| -> Greskell (LabeledP a) | the |
| -> Maybe (ByProjection a b) | optional |
| -> Walk c x x |
.where step with the starting label and P arguments. See also
gWhereP1.
Since: 1.2.0.0
gWhereP2' :: AsLabel a -> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter x x Source #
Monomorphic version of gWhereP2.
Since: 1.2.0.0
Sorting steps
Arguments
| :: [ByComparator s] | following |
| -> Walk Transform s s |
.order step.
ByComparator is an IsString, meaning projection by the given
key.
Paging steps
Repeat step
Arguments
| :: (ToGTraversal g, WalkType c) | |
| => Maybe RepeatLabel | Label for the loop. |
| -> Maybe (RepeatPos, RepeatUntil c s) |
|
| -> Maybe (RepeatPos, RepeatEmit c s) |
|
| -> g c s s | Repeated traversal |
| -> Walk c s s |
.repeat step.
Since: 1.0.1.0
Arguments
| :: Greskell Int | Repeat count. If it's less than or equal to 0, the repeated traversal is never executed. |
| -> Maybe (RepeatPos, RepeatUntil c s) |
.times modulator before the .repeat step. It always returns
Just.
Since: 1.0.1.0
gUntilHead :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s) Source #
.until modulator before the .repeat step. It always returns
Just.
Since: 1.0.1.0
gUntilTail :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s) Source #
.until modulator after the .repeat step. It always returns
Just.
Since: 1.0.1.0
gEmitHead :: Maybe (RepeatPos, RepeatEmit c s) Source #
.emit modulator without argument before the .repeat step. It
always returns Just.
Since: 1.0.1.0
gEmitTail :: Maybe (RepeatPos, RepeatEmit c s) Source #
.emit modulator without argument after the .repeat step. It
always returns Just.
Since: 1.0.1.0
gEmitHeadT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s) Source #
.emit modulator with a sub-traversal argument before the
.repeat step. It always returns Just.
Since: 1.0.1.0
gEmitTailT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s) Source #
.emit modulator with a sub-traversal argument after the
.repeat step. It always returns Just.
Since: 1.0.1.0
data RepeatUntil c s where Source #
.until or .times modulator step.
Type c is the WalkType of the parent .repeat step. Type s
is the start (and end) type of the .repeat step.
Since: 1.0.1.0
Constructors
| RepeatTimes :: Greskell Int -> RepeatUntil c s |
|
| RepeatUntilT :: (WalkType cc, WalkType c, Split cc c) => GTraversal cc s e -> RepeatUntil c s |
|
Instances
| Show (RepeatUntil c s) Source # | |
Defined in Data.Greskell.GTraversal Methods showsPrec :: Int -> RepeatUntil c s -> ShowS # show :: RepeatUntil c s -> String # showList :: [RepeatUntil c s] -> ShowS # | |
data RepeatEmit c s where Source #
.emit modulator step.
Type c is the WalkType of the parent .repeat step. Type s
is the start (and end) type of the .repeat step.
Since: 1.0.1.0
Constructors
| RepeatEmit :: RepeatEmit c s |
|
| RepeatEmitT :: (WalkType cc, WalkType c, Split cc c) => GTraversal cc s e -> RepeatEmit c s |
|
Instances
| Show (RepeatEmit c s) Source # | |
Defined in Data.Greskell.GTraversal Methods showsPrec :: Int -> RepeatEmit c s -> ShowS # show :: RepeatEmit c s -> String # showList :: [RepeatEmit c s] -> ShowS # | |
Position of a step modulator relative to .repeat step.
Since: 1.0.1.0
Constructors
| RepeatHead | Modulator before the |
| RepeatTail | Modulator after the |
Instances
| Bounded RepeatPos Source # | |
| Enum RepeatPos Source # | |
Defined in Data.Greskell.GTraversal Methods succ :: RepeatPos -> RepeatPos # pred :: RepeatPos -> RepeatPos # fromEnum :: RepeatPos -> Int # enumFrom :: RepeatPos -> [RepeatPos] # enumFromThen :: RepeatPos -> RepeatPos -> [RepeatPos] # enumFromTo :: RepeatPos -> RepeatPos -> [RepeatPos] # enumFromThenTo :: RepeatPos -> RepeatPos -> RepeatPos -> [RepeatPos] # | |
| Show RepeatPos Source # | |
| Eq RepeatPos Source # | |
| Ord RepeatPos Source # | |
newtype RepeatLabel Source #
A label that points to a loop created by .repeat step. It can
be used by .loops step to specify the loop.
Since: 1.0.1.0
Constructors
| RepeatLabel | |
Fields | |
Instances
Branching steps
gUnion :: (ToGTraversal g, WalkType c) => [g c s e] -> Walk c s e Source #
.union step.
Since: 1.0.1.0
gCoalesce :: (ToGTraversal g, Split cc c, Lift Transform c, WalkType c, WalkType cc) => [g cc s e] -> Walk c s e Source #
Arguments
| :: (ToGTraversal g, Split cc c, WalkType cc, WalkType c) | |
| => g cc s ep | the predicate traversal. |
| -> g c s e | The traversal executed if the predicate traversal outputs something. |
| -> g c s e | The traversal executed if the predicate traversal outputs nothing. |
| -> Walk c s e |
.choose step with if-then-else style.
Since: 1.0.1.0
Barrier steps
Arguments
| :: WalkType c | |
| => Maybe (Greskell Int) | Max number of traversers kept at this barrier. |
| -> Walk c s s |
.barrier step.
Since: 1.0.1.0
Arguments
| :: Maybe (ByProjection s e) |
|
| -> Walk Transform s s |
.dedup step without argument.
.dedup step is Transform because the filtering decision depends
on the sequence (order) of input elements.
Since: 1.0.1.0
gDedupN :: AsLabel a -> [AsLabel a] -> Maybe (ByProjection a e) -> Walk Transform s s Source #
.dedup step with at least one argument. The tuple specified by
the AsLabels is used as the criterion of deduplication.
Since: 1.0.1.0
Transformation steps
gFlatMap :: (Lift Transform c, Split cc c, ToGTraversal g, WalkType c, WalkType cc) => g cc s e -> Walk c s e Source #
gFlatMap' :: ToGTraversal g => g Transform s e -> Walk Transform s e Source #
Monomorphic version of gFlatMap.
Since: 1.1.0.0
gV :: Vertex v => [Greskell (ElementID v)] -> Walk Transform s v Source #
.V step.
For each input item, .V step emits vertices selected by the
argument (or all vertices if the empty list is passed.)
Since: 0.2.0.0
gV' :: [Greskell (ElementID AVertex)] -> Walk Transform s AVertex Source #
Monomorphic version of gV.
Since: 0.2.0.0
gProject :: LabeledByProjection s -> [LabeledByProjection s] -> Walk Transform s (PMap Single GValue) Source #
.project step.
Since: 1.0.0.0
As step
Accessor steps
gProperties :: (Element s, Property p, ElementProperty s ~ p) => [Key s v] -> Walk Transform s (p v) Source #
.properties step.
gValueMap :: Element s => Keys s -> Walk Transform s (PMap (ElementPropertyContainer s) GValue) Source #
.valueMap step.
Since: 1.0.0.0
gElementMap :: Element s => Keys s -> Walk Transform s (PMap Single GValue) Source #
.elementMap step.
Since: 2.0.1.0
gSelectN :: AsLabel a -> AsLabel b -> [AsLabel c] -> Walk Transform s (SelectedMap GValue) Source #
.select step with more than one arguments.
Since: 0.2.2.0
gSelectBy1 :: AsLabel a -> ByProjection a b -> Walk Transform s b Source #
.select step with one argument followed by .by step.
Since: 0.2.2.0
gSelectByN :: AsLabel a -> AsLabel a -> [AsLabel a] -> ByProjection a b -> Walk Transform s (SelectedMap b) Source #
.select step with more than one arguments followed by .by
step.
Since: 0.2.2.0
gUnfold :: AsIterator a => Walk Transform a (IteratorItem a) Source #
.unfold step.
Note that we use AsIterator here because basically the .unfold
step does the same thing as IteratorUtils.asIterator function in
Tinkerpop. However, Tinkerpop's implementation of .unfold step
doesn't necessarily use asIterator, so there may be some corner
cases where asIterator and .unfold step behave differently.
Since: 1.0.1.0
gPathBy :: ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b) Source #
.path step with one or more .by modulations.
Since: 1.1.0.0
Summarizing steps
Graph traversal steps
.out step
Monomorphic version of gOut.
.outE step
gOutE' :: Vertex v => [Greskell Text] -> Walk Transform v AEdge Source #
Monomorphic version of gOutE.
.in step
.inE step.
Monomorphic version of gInE.
Match step
gMatch :: Logic MatchPattern -> Walk Transform a MatchResult Source #
.match step.
If the top-level Logic of the argument is And, the
patterns are directly passed to the .match step arguments.
The result of .match step, MatchResult, is an opaque
type. Basically you should not use it. Instead, you should use
gSelectN etc to access the path history labels inside the
MatchPattern.
See also: https://groups.google.com/g/gremlin-users/c/HVtldzV0Xk8
Since: 1.2.0.0
data MatchPattern where Source #
A pattern for .match step.
Since: 1.2.0.0
Constructors
| MatchPattern :: AsLabel a -> Walk Transform a b -> MatchPattern | A pattern with the starting |
mPattern :: (WalkType c, Lift c Transform) => AsLabel a -> Walk c a b -> Logic MatchPattern Source #
A convenient function to make a MatchPattern wrapped by
Leaf.
Since: 1.2.0.0
data MatchResult Source #
Result of .match step.
Since: 1.2.0.0
Side-effect steps
gSideEffect :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s Source #
.sideEffect step that takes a traversal.
gSideEffect' :: (ToGTraversal g, WalkType c, Split c SideEffect) => g c s e -> Walk SideEffect s s Source #
Monomorphic version of gSideEffect. The result walk is always
SideEffect type.
Graph manipulation steps
gAddE :: (Vertex vs, Vertex ve, Edge e) => Greskell Text -> AddAnchor vs ve -> Walk SideEffect vs e Source #
.addE step. Supported since TinkerPop 3.1.0.
Since: 0.2.0.0
gAddE' :: Greskell Text -> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge Source #
Monomorphic version of gAddE.
Since: 0.2.0.0
gFrom :: ToGTraversal g => g Transform s e -> AddAnchor s e Source #
.from step with a traversal.
Since: 0.2.0.0
gTo :: ToGTraversal g => g Transform s e -> AddAnchor s e Source #
.to step with a traversal.
Since: 0.2.0.0
Arguments
| :: Element e | |
| => Key e v | key of the property |
| -> Greskell v | value of the property |
| -> Walk SideEffect e e |
Simple .property step. It adds a value to the property.
Since: 0.2.0.0
Arguments
| :: (Vertex e, vp ~ ElementProperty e, Property vp, Element (vp v)) | |
| => Maybe (Greskell Cardinality) | optional cardinality of the vertex property. |
| -> Key e v | key of the vertex property |
| -> Greskell v | value of the vertex property |
| -> [KeyValue (vp v)] | optional meta-properties for the vertex property. |
| -> Walk SideEffect e e |
.property step for Vertex.
Since: 0.2.0.0
.by steps
.by steps are not Walk on their own because they are always used in conjunction with
other steps like gOrder.
data ByProjection s e where Source #
Projection from type s to type e used in .by step. You can
also use gBy to construct ByProjection.
Constructors
| ByProjection :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p) |
Instances
| IsString (ByProjection s e) Source # | Projection by literal property key. |
Defined in Data.Greskell.GTraversal Methods fromString :: String -> ByProjection s e # | |
| ProjectionLike (ByProjection s e) Source # | |
Defined in Data.Greskell.GTraversal Associated Types type ProjectionLikeStart (ByProjection s e) Source # type ProjectionLikeEnd (ByProjection s e) Source # | |
| type ProjectionLikeEnd (ByProjection s e) Source # | |
Defined in Data.Greskell.GTraversal | |
| type ProjectionLikeStart (ByProjection s e) Source # | |
Defined in Data.Greskell.GTraversal | |
class ProjectionLike p Source #
Data types that mean a projection from one type to another.
Associated Types
type ProjectionLikeStart p Source #
The start type of the projection.
type ProjectionLikeEnd p Source #
The end type of the projection.
Instances
data ByComparator s where Source #
Comparison of type s used in .by step. You can also use
gBy1 and gBy2 to construct ByComparator.
Constructors
| ByComparatorProj :: ByProjection s e -> ByComparator s | Type |
| ByComparatorComp :: Comparator comp => Greskell comp -> ByComparator (CompareArg comp) | Type |
| ByComparatorProjComp :: Comparator comp => ByProjection s (CompareArg comp) -> Greskell comp -> ByComparator s | Type |
Instances
| IsString (ByComparator s) Source # |
|
Defined in Data.Greskell.GTraversal Methods fromString :: String -> ByComparator s # | |
data LabeledByProjection s where Source #
A ByProjection associated with an AsLabel. You can construct
it by gByL.
Since: 1.0.0.0
Constructors
| LabeledByProjection :: AsLabel a -> ByProjection s a -> LabeledByProjection s |
gBy :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p) Source #
.by step with 1 argument, used for projection.
gBy1 :: (ProjectionLike p, ToGreskell p) => p -> ByComparator (ProjectionLikeStart p) Source #
.by step with 1 argument, used for comparison.
gBy2 :: (ProjectionLike p, ToGreskell p, Comparator comp, ProjectionLikeEnd p ~ CompareArg comp) => p -> Greskell comp -> ByComparator (ProjectionLikeStart p) Source #
.by step with 2 arguments, used for comparison.
gByL :: (ProjectionLike p, ToGreskell p) => AsLabel (ProjectionLikeEnd p) -> p -> LabeledByProjection (ProjectionLikeStart p) Source #
.by step associated with an AsLabel.
Since: 1.0.0.0