{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
module Data.Greskell.GTraversal
(
GTraversal (..)
, GraphTraversal
, ToGTraversal (..)
, Walk
, GraphTraversalSource
, WalkType
, Filter
, Transform
, SideEffect
, Lift
, Split
, source
, sV
, sV'
, sE
, sE'
, sAddV
, sAddV'
, (&.)
, ($.)
, (<$.>)
, (<*.>)
, gIterate
, unsafeGTraversal
, unsafeWalk
, modulateWith
, gIdentity
, gIdentity'
, gFilter
, gCyclicPath
, gCyclicPath'
, gSimplePath
, gSimplePath'
, gIs
, gIs'
, gIsP
, gIsP'
, gHas1
, gHas1'
, gHas2
, gHas2'
, gHas2P
, gHas2P'
, gHasLabel
, gHasLabel'
, gHasLabelP
, gHasLabelP'
, gHasId
, gHasId'
, gHasIdP
, gHasIdP'
, gHasKey
, gHasKey'
, gHasKeyP
, gHasKeyP'
, gHasValue
, gHasValue'
, gHasValueP
, gHasValueP'
, gAnd
, gOr
, gNot
, gWhereP1
, gWhereP1'
, gWhereP2
, gWhereP2'
, gOrder
, gRange
, gLimit
, gTail
, gSkip
, gRepeat
, gTimes
, gUntilHead
, gUntilTail
, gEmitHead
, gEmitTail
, gEmitHeadT
, gEmitTailT
, gLoops
, RepeatUntil (..)
, RepeatEmit (..)
, RepeatPos (..)
, RepeatLabel (..)
, gLocal
, gUnion
, gCoalesce
, gChoose3
, gBarrier
, gDedup
, gDedupN
, gFlatMap
, gFlatMap'
, gV
, gV'
, gConstant
, gProject
, gAs
, gValues
, gProperties
, gId
, gLabel
, gValueMap
, gElementMap
, gSelect1
, gSelectN
, gSelectBy1
, gSelectByN
, gUnfold
, gPath
, gPathBy
, gFold
, gCount
, gOut
, gOut'
, gOutE
, gOutE'
, gOutV
, gOutV'
, gIn
, gIn'
, gInE
, gInE'
, gInV
, gInV'
, gMatch
, MatchPattern (..)
, mPattern
, MatchResult
, gSideEffect
, gSideEffect'
, gAddV
, gAddV'
, gAddE
, gAddE'
, AddAnchor
, gFrom
, gTo
, gDrop
, gDropP
, gProperty
, gPropertyV
, ByProjection (..)
, ProjectionLike (..)
, ByComparator (..)
, LabeledByProjection (..)
, gBy
, gBy1
, gBy2
, gByL
, examples
, showWalkType
, showLift
, showSplit
) where
import Control.Applicative ((<$>), (<*>))
import Control.Category (Category, (>>>))
import qualified Control.Category as Category
import Data.Aeson (Value)
import Data.Bifunctor (Bifunctor (bimap))
import Data.Foldable (foldl')
import Data.Function ((&))
import Data.List.NonEmpty (NonEmpty (..))
import Data.Monoid (Monoid (..), mconcat, (<>))
import Data.Proxy (Proxy)
import Data.Semigroup (Semigroup, sconcat)
import qualified Data.Semigroup as Semigroup
import Data.String (IsString (..))
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL
import Data.Greskell.AsIterator (AsIterator (IteratorItem))
import Data.Greskell.AsLabel (AsLabel, LabeledP, SelectedMap)
import Data.Greskell.Graph (AEdge, AVertex, AVertexProperty, Cardinality, Edge,
Element (..), ElementID (..), Key, KeyValue (..),
Keys (..), Path, Property (..), T, Vertex, cList, tId,
toGremlinKeys, (-:), (=:))
import Data.Greskell.GraphSON (FromGraphSON, GValue)
import Data.Greskell.Gremlin (Comparator (..), P, oDecr, oIncr, pBetween, pEq, pLte)
import Data.Greskell.Greskell (Greskell, ToGreskell (..), gvalueInt, toGremlin,
toGremlinLazy, unsafeFunCall, unsafeGreskell,
unsafeGreskellLazy)
import qualified Data.Greskell.Greskell as Greskell
import Data.Greskell.Logic (Logic)
import qualified Data.Greskell.Logic as Logic
import Data.Greskell.PMap (PMap, Single)
newtype GTraversal c s e
= GTraversal { forall c s e. GTraversal c s e -> Greskell (GraphTraversal c s e)
unGTraversal :: Greskell (GraphTraversal c s e) }
deriving (Int -> GTraversal c s e -> ShowS
[GTraversal c s e] -> ShowS
GTraversal c s e -> String
(Int -> GTraversal c s e -> ShowS)
-> (GTraversal c s e -> String)
-> ([GTraversal c s e] -> ShowS)
-> Show (GTraversal c s e)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall c s e. Int -> GTraversal c s e -> ShowS
forall c s e. [GTraversal c s e] -> ShowS
forall c s e. GTraversal c s e -> String
$cshowsPrec :: forall c s e. Int -> GTraversal c s e -> ShowS
showsPrec :: Int -> GTraversal c s e -> ShowS
$cshow :: forall c s e. GTraversal c s e -> String
show :: GTraversal c s e -> String
$cshowList :: forall c s e. [GTraversal c s e] -> ShowS
showList :: [GTraversal c s e] -> ShowS
Show)
instance Functor (GTraversal c s) where
fmap :: forall a b. (a -> b) -> GTraversal c s a -> GTraversal c s b
fmap a -> b
f (GTraversal Greskell (GraphTraversal c s a)
g) = Greskell (GraphTraversal c s b) -> GTraversal c s b
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal c s b) -> GTraversal c s b)
-> Greskell (GraphTraversal c s b) -> GTraversal c s b
forall a b. (a -> b) -> a -> b
$ (GraphTraversal c s a -> GraphTraversal c s b)
-> Greskell (GraphTraversal c s a)
-> Greskell (GraphTraversal c s b)
forall a b. (a -> b) -> Greskell a -> Greskell b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> GraphTraversal c s a -> GraphTraversal c s b
forall a b.
(a -> b) -> GraphTraversal c s a -> GraphTraversal c s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Greskell (GraphTraversal c s a)
g
instance Bifunctor (GTraversal c) where
bimap :: forall a b c d.
(a -> b) -> (c -> d) -> GTraversal c a c -> GTraversal c b d
bimap a -> b
f1 c -> d
f2 (GTraversal Greskell (GraphTraversal c a c)
g) = Greskell (GraphTraversal c b d) -> GTraversal c b d
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal c b d) -> GTraversal c b d)
-> Greskell (GraphTraversal c b d) -> GTraversal c b d
forall a b. (a -> b) -> a -> b
$ (GraphTraversal c a c -> GraphTraversal c b d)
-> Greskell (GraphTraversal c a c)
-> Greskell (GraphTraversal c b d)
forall a b. (a -> b) -> Greskell a -> Greskell b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b)
-> (c -> d) -> GraphTraversal c a c -> GraphTraversal c b d
forall a b c d.
(a -> b)
-> (c -> d) -> GraphTraversal c a c -> GraphTraversal c b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> b
f1 c -> d
f2) Greskell (GraphTraversal c a c)
g
instance ToGreskell (GTraversal c s e) where
type GreskellReturn (GTraversal c s e) = GraphTraversal c s e
toGreskell :: GTraversal c s e -> Greskell (GreskellReturn (GTraversal c s e))
toGreskell = GTraversal c s e -> Greskell (GreskellReturn (GTraversal c s e))
GTraversal c s e -> Greskell (GraphTraversal c s e)
forall c s e. GTraversal c s e -> Greskell (GraphTraversal c s e)
unGTraversal
data GraphTraversal c s e = GraphTraversal deriving (Int -> GraphTraversal c s e -> ShowS
[GraphTraversal c s e] -> ShowS
GraphTraversal c s e -> String
(Int -> GraphTraversal c s e -> ShowS)
-> (GraphTraversal c s e -> String)
-> ([GraphTraversal c s e] -> ShowS)
-> Show (GraphTraversal c s e)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall c s e. Int -> GraphTraversal c s e -> ShowS
forall c s e. [GraphTraversal c s e] -> ShowS
forall c s e. GraphTraversal c s e -> String
$cshowsPrec :: forall c s e. Int -> GraphTraversal c s e -> ShowS
showsPrec :: Int -> GraphTraversal c s e -> ShowS
$cshow :: forall c s e. GraphTraversal c s e -> String
show :: GraphTraversal c s e -> String
$cshowList :: forall c s e. [GraphTraversal c s e] -> ShowS
showList :: [GraphTraversal c s e] -> ShowS
Show)
instance AsIterator (GraphTraversal c s e) where
type IteratorItem (GraphTraversal c s e) = e
instance Functor (GraphTraversal c s) where
fmap :: forall a b.
(a -> b) -> GraphTraversal c s a -> GraphTraversal c s b
fmap a -> b
_ GraphTraversal c s a
GraphTraversal = GraphTraversal c s b
forall c s e. GraphTraversal c s e
GraphTraversal
instance Bifunctor (GraphTraversal c) where
bimap :: forall a b c d.
(a -> b)
-> (c -> d) -> GraphTraversal c a c -> GraphTraversal c b d
bimap a -> b
_ c -> d
_ GraphTraversal c a c
GraphTraversal = GraphTraversal c b d
forall c s e. GraphTraversal c s e
GraphTraversal
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
instance ToGTraversal GTraversal where
toGTraversal :: forall c s e. WalkType c => GTraversal c s e -> GTraversal c s e
toGTraversal = GTraversal c s e -> GTraversal c s e
forall a. a -> a
id
liftWalk :: forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
liftWalk (GTraversal Greskell (GraphTraversal from s e)
g) = Greskell (GraphTraversal to s e) -> GTraversal to s e
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal to s e) -> GTraversal to s e)
-> Greskell (GraphTraversal to s e) -> GTraversal to s e
forall a b. (a -> b) -> a -> b
$ Text -> Greskell (GraphTraversal to s e)
forall a. Text -> Greskell a
unsafeGreskellLazy (Text -> Greskell (GraphTraversal to s e))
-> Text -> Greskell (GraphTraversal to s e)
forall a b. (a -> b) -> a -> b
$ Greskell (GraphTraversal from s e) -> Text
forall a. ToGreskell a => a -> Text
toGremlinLazy Greskell (GraphTraversal from s e)
g
unsafeCastStart :: forall c s1 e s2.
WalkType c =>
GTraversal c s1 e -> GTraversal c s2 e
unsafeCastStart (GTraversal Greskell (GraphTraversal c s1 e)
g) = Greskell (GraphTraversal c s2 e) -> GTraversal c s2 e
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal c s2 e) -> GTraversal c s2 e)
-> Greskell (GraphTraversal c s2 e) -> GTraversal c s2 e
forall a b. (a -> b) -> a -> b
$ Text -> Greskell (GraphTraversal c s2 e)
forall a. Text -> Greskell a
unsafeGreskellLazy (Text -> Greskell (GraphTraversal c s2 e))
-> Text -> Greskell (GraphTraversal c s2 e)
forall a b. (a -> b) -> a -> b
$ Greskell (GraphTraversal c s1 e) -> Text
forall a. ToGreskell a => a -> Text
toGremlinLazy Greskell (GraphTraversal c s1 e)
g
unsafeCastEnd :: forall c s e1 e2.
WalkType c =>
GTraversal c s e1 -> GTraversal c s e2
unsafeCastEnd (GTraversal Greskell (GraphTraversal c s e1)
g) = Greskell (GraphTraversal c s e2) -> GTraversal c s e2
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal c s e2) -> GTraversal c s e2)
-> Greskell (GraphTraversal c s e2) -> GTraversal c s e2
forall a b. (a -> b) -> a -> b
$ Text -> Greskell (GraphTraversal c s e2)
forall a. Text -> Greskell a
unsafeGreskellLazy (Text -> Greskell (GraphTraversal c s e2))
-> Text -> Greskell (GraphTraversal c s e2)
forall a b. (a -> b) -> a -> b
$ Greskell (GraphTraversal c s e1) -> Text
forall a. ToGreskell a => a -> Text
toGremlinLazy Greskell (GraphTraversal c s e1)
g
newtype Walk c s e
= Walk TL.Text
deriving (Int -> Walk c s e -> ShowS
[Walk c s e] -> ShowS
Walk c s e -> String
(Int -> Walk c s e -> ShowS)
-> (Walk c s e -> String)
-> ([Walk c s e] -> ShowS)
-> Show (Walk c s e)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall c s e. Int -> Walk c s e -> ShowS
forall c s e. [Walk c s e] -> ShowS
forall c s e. Walk c s e -> String
$cshowsPrec :: forall c s e. Int -> Walk c s e -> ShowS
showsPrec :: Int -> Walk c s e -> ShowS
$cshow :: forall c s e. Walk c s e -> String
show :: Walk c s e -> String
$cshowList :: forall c s e. [Walk c s e] -> ShowS
showList :: [Walk c s e] -> ShowS
Show)
instance WalkType c => Category (Walk c) where
id :: forall a. Walk c a a
id = Walk c a a
forall c s. WalkType c => Walk c s s
gIdentity
(Walk Text
bc) . :: forall b c a. Walk c b c -> Walk c a b -> Walk c a c
. (Walk Text
ab) = Text -> Walk c a c
forall c s e. Text -> Walk c s e
Walk (Text
ab Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
bc)
instance WalkType c => Semigroup (Walk c s s) where
<> :: Walk c s s -> Walk c s s -> Walk c s s
(<>) = Walk c s s -> Walk c s s -> Walk c s s
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
(Category.>>>)
instance WalkType c => Monoid (Walk c s s) where
mempty :: Walk c s s
mempty = Walk c s s
forall a. Walk c a a
forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
Category.id
mappend :: Walk c s s -> Walk c s s -> Walk c s s
mappend = Walk c s s -> Walk c s s -> Walk c s s
forall a. Semigroup a => a -> a -> a
(Semigroup.<>)
instance Functor (Walk c s) where
fmap :: forall a b. (a -> b) -> Walk c s a -> Walk c s b
fmap a -> b
_ (Walk Text
t) = Text -> Walk c s b
forall c s e. Text -> Walk c s e
Walk Text
t
instance Bifunctor (Walk c) where
bimap :: forall a b c d. (a -> b) -> (c -> d) -> Walk c a c -> Walk c b d
bimap a -> b
_ c -> d
_ (Walk Text
t) = Text -> Walk c b d
forall c s e. Text -> Walk c s e
Walk Text
t
instance ToGTraversal Walk where
toGTraversal :: forall c s e. WalkType c => Walk c s e -> GTraversal c s e
toGTraversal (Walk Text
t) = Greskell (GraphTraversal c s e) -> GTraversal c s e
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal c s e) -> GTraversal c s e)
-> Greskell (GraphTraversal c s e) -> GTraversal c s e
forall a b. (a -> b) -> a -> b
$ Text -> Greskell (GraphTraversal c s e)
forall a. Text -> Greskell a
unsafeGreskellLazy (Text
"__" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
t)
liftWalk :: forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
liftWalk (Walk Text
t) = Text -> Walk to s e
forall c s e. Text -> Walk c s e
Walk Text
t
unsafeCastStart :: forall c s1 e s2. WalkType c => Walk c s1 e -> Walk c s2 e
unsafeCastStart (Walk Text
t) = Text -> Walk c s2 e
forall c s e. Text -> Walk c s e
Walk Text
t
unsafeCastEnd :: forall c s e1 e2. WalkType c => Walk c s e1 -> Walk c s e2
unsafeCastEnd (Walk Text
t) = Text -> Walk c s e2
forall c s e. Text -> Walk c s e
Walk Text
t
instance WalkType c => ToGreskell (Walk c s e) where
type GreskellReturn (Walk c s e) = GraphTraversal c s e
toGreskell :: Walk c s e -> Greskell (GreskellReturn (Walk c s e))
toGreskell = GTraversal c s e -> Greskell (GreskellReturn (GTraversal c s e))
GTraversal c s e -> Greskell (GraphTraversal c s e)
forall a. ToGreskell a => a -> Greskell (GreskellReturn a)
toGreskell (GTraversal c s e -> Greskell (GraphTraversal c s e))
-> (Walk c s e -> GTraversal c s e)
-> Walk c s e
-> Greskell (GraphTraversal c s e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Walk c s e -> GTraversal c s e
forall c s e. WalkType c => Walk c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal
class WalkType t where
showWalkType :: Proxy t -> String
data Filter
instance WalkType Filter where
showWalkType :: Proxy Filter -> String
showWalkType Proxy Filter
_ = String
"Filter"
data Transform
instance WalkType Transform where
showWalkType :: Proxy Transform -> String
showWalkType Proxy Transform
_ = String
"Transform"
data SideEffect
instance WalkType SideEffect where
showWalkType :: Proxy SideEffect -> String
showWalkType Proxy SideEffect
_ = String
"SideEffect"
class Lift from to where
showLift :: Proxy from -> Proxy to -> String
genericShowLift :: (WalkType from, WalkType to) => Proxy from -> Proxy to -> String
genericShowLift :: forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowLift Proxy from
f Proxy to
t = String
"Lift " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Proxy from -> String
forall t. WalkType t => Proxy t -> String
showWalkType Proxy from
f String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Proxy to -> String
forall t. WalkType t => Proxy t -> String
showWalkType Proxy to
t
instance (WalkType c) => Lift Filter c where
showLift :: Proxy Filter -> Proxy c -> String
showLift = Proxy Filter -> Proxy c -> String
forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowLift
instance Lift Transform Transform where
showLift :: Proxy Transform -> Proxy Transform -> String
showLift = Proxy Transform -> Proxy Transform -> String
forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowLift
instance Lift Transform SideEffect where
showLift :: Proxy Transform -> Proxy SideEffect -> String
showLift = Proxy Transform -> Proxy SideEffect -> String
forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowLift
instance Lift SideEffect SideEffect where
showLift :: Proxy SideEffect -> Proxy SideEffect -> String
showLift = Proxy SideEffect -> Proxy SideEffect -> String
forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowLift
class Split c p where
showSplit :: Proxy c -> Proxy p -> String
genericShowSplit :: (WalkType c, WalkType p) => Proxy c -> Proxy p -> String
genericShowSplit :: forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowSplit Proxy c
c Proxy p
p = String
"Split " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Proxy c -> String
forall t. WalkType t => Proxy t -> String
showWalkType Proxy c
c String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Proxy p -> String
forall t. WalkType t => Proxy t -> String
showWalkType Proxy p
p
instance (WalkType p) => Split Filter p where
showSplit :: Proxy Filter -> Proxy p -> String
showSplit = Proxy Filter -> Proxy p -> String
forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowSplit
instance (WalkType p) => Split Transform p where
showSplit :: Proxy Transform -> Proxy p -> String
showSplit = Proxy Transform -> Proxy p -> String
forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowSplit
instance Split SideEffect SideEffect where
showSplit :: Proxy SideEffect -> Proxy SideEffect -> String
showSplit = Proxy SideEffect -> Proxy SideEffect -> String
forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowSplit
data GraphTraversalSource = GraphTraversalSource deriving (Int -> GraphTraversalSource -> ShowS
[GraphTraversalSource] -> ShowS
GraphTraversalSource -> String
(Int -> GraphTraversalSource -> ShowS)
-> (GraphTraversalSource -> String)
-> ([GraphTraversalSource] -> ShowS)
-> Show GraphTraversalSource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GraphTraversalSource -> ShowS
showsPrec :: Int -> GraphTraversalSource -> ShowS
$cshow :: GraphTraversalSource -> String
show :: GraphTraversalSource -> String
$cshowList :: [GraphTraversalSource] -> ShowS
showList :: [GraphTraversalSource] -> ShowS
Show)
source :: Text
-> Greskell GraphTraversalSource
source :: Text -> Greskell GraphTraversalSource
source = Text -> Greskell GraphTraversalSource
forall a. Text -> Greskell a
unsafeGreskell
sourceMethod :: Text -> [Greskell a] -> Greskell GraphTraversalSource -> Greskell b
sourceMethod :: forall a b.
Text -> [Greskell a] -> Greskell GraphTraversalSource -> Greskell b
sourceMethod Text
method_name [Greskell a]
args Greskell GraphTraversalSource
src =
Text -> Greskell b
forall a. Text -> Greskell a
unsafeGreskellLazy (Text -> Greskell b) -> Text -> Greskell b
forall a b. (a -> b) -> a -> b
$ (Greskell GraphTraversalSource -> Text
forall a. ToGreskell a => a -> Text
toGremlinLazy Greskell GraphTraversalSource
src Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> [Text] -> Text
methodCallText Text
method_name ((Greskell a -> Text) -> [Greskell a] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Greskell a -> Text
forall a. ToGreskell a => a -> Text
toGremlin [Greskell a]
args))
sV :: Vertex v
=> [Greskell (ElementID v)]
-> Greskell GraphTraversalSource
-> GTraversal Transform () v
sV :: forall v.
Vertex v =>
[Greskell (ElementID v)]
-> Greskell GraphTraversalSource -> GTraversal Transform () v
sV [Greskell (ElementID v)]
ids Greskell GraphTraversalSource
src = Greskell (GraphTraversal Transform () v)
-> GTraversal Transform () v
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal Transform () v)
-> GTraversal Transform () v)
-> Greskell (GraphTraversal Transform () v)
-> GTraversal Transform () v
forall a b. (a -> b) -> a -> b
$ Text
-> [Greskell (ElementID v)]
-> Greskell GraphTraversalSource
-> Greskell (GraphTraversal Transform () v)
forall a b.
Text -> [Greskell a] -> Greskell GraphTraversalSource -> Greskell b
sourceMethod Text
"V" [Greskell (ElementID v)]
ids Greskell GraphTraversalSource
src
sV' :: [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource
-> GTraversal Transform () AVertex
sV' :: [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' = [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
forall v.
Vertex v =>
[Greskell (ElementID v)]
-> Greskell GraphTraversalSource -> GTraversal Transform () v
sV
sE :: Edge e
=> [Greskell (ElementID e)]
-> Greskell GraphTraversalSource
-> GTraversal Transform () e
sE :: forall e.
Edge e =>
[Greskell (ElementID e)]
-> Greskell GraphTraversalSource -> GTraversal Transform () e
sE [Greskell (ElementID e)]
ids Greskell GraphTraversalSource
src = Greskell (GraphTraversal Transform () e)
-> GTraversal Transform () e
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal Transform () e)
-> GTraversal Transform () e)
-> Greskell (GraphTraversal Transform () e)
-> GTraversal Transform () e
forall a b. (a -> b) -> a -> b
$ Text
-> [Greskell (ElementID e)]
-> Greskell GraphTraversalSource
-> Greskell (GraphTraversal Transform () e)
forall a b.
Text -> [Greskell a] -> Greskell GraphTraversalSource -> Greskell b
sourceMethod Text
"E" [Greskell (ElementID e)]
ids Greskell GraphTraversalSource
src
sE' :: [Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource
-> GTraversal Transform () AEdge
sE' :: [Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
sE' = [Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
forall e.
Edge e =>
[Greskell (ElementID e)]
-> Greskell GraphTraversalSource -> GTraversal Transform () e
sE
sAddV :: Vertex v
=> Greskell Text
-> Greskell GraphTraversalSource
-> GTraversal SideEffect () v
sAddV :: forall v.
Vertex v =>
Greskell Text
-> Greskell GraphTraversalSource -> GTraversal SideEffect () v
sAddV Greskell Text
label Greskell GraphTraversalSource
src = Greskell (GraphTraversal SideEffect () v)
-> GTraversal SideEffect () v
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal SideEffect () v)
-> GTraversal SideEffect () v)
-> Greskell (GraphTraversal SideEffect () v)
-> GTraversal SideEffect () v
forall a b. (a -> b) -> a -> b
$ Text
-> [Greskell Text]
-> Greskell GraphTraversalSource
-> Greskell (GraphTraversal SideEffect () v)
forall a b.
Text -> [Greskell a] -> Greskell GraphTraversalSource -> Greskell b
sourceMethod Text
"addV" [Greskell Text
label] Greskell GraphTraversalSource
src
sAddV' :: Greskell Text -> Greskell GraphTraversalSource -> GTraversal SideEffect () AVertex
sAddV' :: Greskell Text
-> Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex
sAddV' = Greskell Text
-> Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex
forall v.
Vertex v =>
Greskell Text
-> Greskell GraphTraversalSource -> GTraversal SideEffect () v
sAddV
unsafeGTraversal :: Text -> GTraversal c s e
unsafeGTraversal :: forall c s e. Text -> GTraversal c s e
unsafeGTraversal = Greskell (GraphTraversal c s e) -> GTraversal c s e
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal c s e) -> GTraversal c s e)
-> (Text -> Greskell (GraphTraversal c s e))
-> Text
-> GTraversal c s e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Greskell (GraphTraversal c s e)
forall a. Text -> Greskell a
unsafeGreskell
infixl 1 &.
(&.) :: GTraversal c a b -> Walk c b d -> GTraversal c a d
(GTraversal Greskell (GraphTraversal c a b)
gt) &. :: forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. (Walk Text
twalk) = Greskell (GraphTraversal c a d) -> GTraversal c a d
forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal (Greskell (GraphTraversal c a d) -> GTraversal c a d)
-> Greskell (GraphTraversal c a d) -> GTraversal c a d
forall a b. (a -> b) -> a -> b
$ Text -> Greskell (GraphTraversal c a d)
forall a. Text -> Greskell a
unsafeGreskellLazy (Greskell (GraphTraversal c a b) -> Text
forall a. ToGreskell a => a -> Text
toGremlinLazy Greskell (GraphTraversal c a b)
gt Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
twalk)
infixr 0 $.
($.) :: Walk c b d -> GTraversal c a b -> GTraversal c a d
Walk c b d
gs $. :: forall c b d a. Walk c b d -> GTraversal c a b -> GTraversal c a d
$. GTraversal c a b
gt = GTraversal c a b
gt GTraversal c a b -> Walk c b d -> GTraversal c a d
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk c b d
gs
infixr 0 <$.>
(<$.>) :: Functor f => Walk c b d -> f (GTraversal c a b) -> f (GTraversal c a d)
Walk c b d
gs <$.> :: forall (f :: * -> *) c b d a.
Functor f =>
Walk c b d -> f (GTraversal c a b) -> f (GTraversal c a d)
<$.> f (GTraversal c a b)
gt = Walk c b d -> GTraversal c a b -> GTraversal c a d
forall c b d a. Walk c b d -> GTraversal c a b -> GTraversal c a d
($.) Walk c b d
gs (GTraversal c a b -> GTraversal c a d)
-> f (GTraversal c a b) -> f (GTraversal c a d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (GTraversal c a b)
gt
infixr 0 <*.>
(<*.>) :: Applicative f => f (Walk c b d) -> f (GTraversal c a b) -> f (GTraversal c a d)
f (Walk c b d)
gs <*.> :: forall (f :: * -> *) c b d a.
Applicative f =>
f (Walk c b d) -> f (GTraversal c a b) -> f (GTraversal c a d)
<*.> f (GTraversal c a b)
gt = Walk c b d -> GTraversal c a b -> GTraversal c a d
forall c b d a. Walk c b d -> GTraversal c a b -> GTraversal c a d
($.) (Walk c b d -> GTraversal c a b -> GTraversal c a d)
-> f (Walk c b d) -> f (GTraversal c a b -> GTraversal c a d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (Walk c b d)
gs f (GTraversal c a b -> GTraversal c a d)
-> f (GTraversal c a b) -> f (GTraversal c a d)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f (GTraversal c a b)
gt
gIterate :: WalkType c => GTraversal c s e -> GTraversal c s ()
gIterate :: forall c s e. WalkType c => GTraversal c s e -> GTraversal c s ()
gIterate GTraversal c s e
gt = Text -> [Text] -> Walk c e ()
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"iterate" [] Walk c e () -> GTraversal c s e -> GTraversal c s ()
forall c b d a. Walk c b d -> GTraversal c a b -> GTraversal c a d
$. GTraversal c s e
gt
methodCallText :: Text
-> [Text]
-> TL.Text
methodCallText :: Text -> [Text] -> Text
methodCallText Text
name [Text]
args = (Text
"." Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Greskell Any -> Text
forall a. ToGreskell a => a -> Text
toGremlinLazy (Greskell Any -> Text) -> Greskell Any -> Text
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Greskell Any
forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
name [Text]
args
unsafeWalk :: WalkType c
=> Text
-> [Text]
-> Walk c s e
unsafeWalk :: forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
name [Text]
args = Text -> Walk c s e
forall c s e. Text -> Walk c s e
Walk (Text -> Walk c s e) -> Text -> Walk c s e
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
methodCallText Text
name [Text]
args
modulateWith :: (WalkType c)
=> Walk c s e
-> [Walk c e e]
-> Walk c s e
modulateWith :: forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith Walk c s e
w [] = Walk c s e
w
modulateWith Walk c s e
w (Walk c e e
m:[Walk c e e]
rest) = Walk c s e
w Walk c s e -> Walk c e e -> Walk c s e
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> NonEmpty (Walk c e e) -> Walk c e e
forall a. Semigroup a => NonEmpty a -> a
sconcat (Walk c e e
m Walk c e e -> [Walk c e e] -> NonEmpty (Walk c e e)
forall a. a -> [a] -> NonEmpty a
:| [Walk c e e]
rest)
gIdentity :: WalkType c => Walk c s s
gIdentity :: forall c s. WalkType c => Walk c s s
gIdentity = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s) -> Walk Filter s s -> Walk c s s
forall a b. (a -> b) -> a -> b
$ Walk Filter s s
forall s. Walk Filter s s
gIdentity'
gIdentity' :: Walk Filter s s
gIdentity' :: forall s. Walk Filter s s
gIdentity' = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"identity" []
travToG :: (ToGTraversal g, WalkType c) => g c s e -> Text
travToG :: forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG = Greskell (GraphTraversal c s e) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Greskell (GraphTraversal c s e) -> Text)
-> (g c s e -> Greskell (GraphTraversal c s e)) -> g c s e -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GTraversal c s e -> Greskell (GraphTraversal c s e)
forall c s e. GTraversal c s e -> Greskell (GraphTraversal c s e)
unGTraversal (GTraversal c s e -> Greskell (GraphTraversal c s e))
-> (g c s e -> GTraversal c s e)
-> g c s e
-> Greskell (GraphTraversal c s e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g c s e -> GTraversal c s e
forall c s e. WalkType c => g c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal
gFilter :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
gFilter :: forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gFilter g c s e
walk = Text -> [Text] -> Walk p s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"filter" [g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s e
walk]
gCyclicPath :: (WalkType c) => Walk c a a
gCyclicPath :: forall c s. WalkType c => Walk c s s
gCyclicPath = Walk Filter a a -> Walk c a a
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk Walk Filter a a
forall s. Walk Filter s s
gCyclicPath'
gCyclicPath' :: Walk Filter a a
gCyclicPath' :: forall s. Walk Filter s s
gCyclicPath' = Text -> [Text] -> Walk Filter a a
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"cyclicPath" []
gSimplePath :: (WalkType c) => Walk c a a
gSimplePath :: forall c s. WalkType c => Walk c s s
gSimplePath = Walk Filter a a -> Walk c a a
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk Walk Filter a a
forall s. Walk Filter s s
gSimplePath'
gSimplePath' :: Walk Filter a a
gSimplePath' :: forall s. Walk Filter s s
gSimplePath' = Text -> [Text] -> Walk Filter a a
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"simplePath" []
gWherePGeneric :: Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWherePGeneric :: forall a b x.
Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWherePGeneric Maybe (AsLabel a)
mstart Greskell (LabeledP a)
p Maybe (ByProjection a b)
mby = Walk Filter x x -> [Walk Filter x x] -> Walk Filter x x
forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith Walk Filter x x
wh [Walk Filter x x]
mods
where
wh :: Walk Filter x x
wh = Text -> [Text] -> Walk Filter x x
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"where" ([Text] -> Walk Filter x x) -> [Text] -> Walk Filter x x
forall a b. (a -> b) -> a -> b
$ [Text]
start_args [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Greskell (LabeledP a) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (LabeledP a)
p]
start_args :: [Text]
start_args = [Text] -> (AsLabel a -> [Text]) -> Maybe (AsLabel a) -> [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (Text -> [Text]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> [Text]) -> (AsLabel a -> Text) -> AsLabel a -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AsLabel a -> Text
forall a. ToGreskell a => a -> Text
toGremlin) Maybe (AsLabel a)
mstart
mods :: [Walk Filter x x]
mods = [Walk Filter x x]
-> (ByProjection a b -> [Walk Filter x x])
-> Maybe (ByProjection a b)
-> [Walk Filter x x]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (Walk Filter x x -> [Walk Filter x x]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Walk Filter x x -> [Walk Filter x x])
-> (ByProjection a b -> Walk Filter x x)
-> ByProjection a b
-> [Walk Filter x x]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByProjection a b -> Walk Filter x x
forall t a b c. WalkType t => ByProjection a b -> Walk t c c
byStep) Maybe (ByProjection a b)
mby
gWhereP1 :: WalkType c
=> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk c a a
gWhereP1 :: forall c a b.
WalkType c =>
Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c a a
gWhereP1 Greskell (LabeledP a)
p Maybe (ByProjection a b)
mby = Walk Filter a a -> Walk c a a
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter a a -> Walk c a a) -> Walk Filter a a -> Walk c a a
forall a b. (a -> b) -> a -> b
$ Greskell (LabeledP a)
-> Maybe (ByProjection a b) -> Walk Filter a a
forall a b.
Greskell (LabeledP a)
-> Maybe (ByProjection a b) -> Walk Filter a a
gWhereP1' Greskell (LabeledP a)
p Maybe (ByProjection a b)
mby
gWhereP1' :: Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter a a
gWhereP1' :: forall a b.
Greskell (LabeledP a)
-> Maybe (ByProjection a b) -> Walk Filter a a
gWhereP1' Greskell (LabeledP a)
p Maybe (ByProjection a b)
mby = Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter a a
forall a b x.
Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWherePGeneric Maybe (AsLabel a)
forall a. Maybe a
Nothing Greskell (LabeledP a)
p Maybe (ByProjection a b)
mby
gWhereP2 :: WalkType c
=> AsLabel a
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk c x x
gWhereP2 :: forall c a b x.
WalkType c =>
AsLabel a
-> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c x x
gWhereP2 AsLabel a
s Greskell (LabeledP a)
p Maybe (ByProjection a b)
b = Walk Filter x x -> Walk c x x
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter x x -> Walk c x x) -> Walk Filter x x -> Walk c x x
forall a b. (a -> b) -> a -> b
$ AsLabel a
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
forall a b x.
AsLabel a
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWhereP2' AsLabel a
s Greskell (LabeledP a)
p Maybe (ByProjection a b)
b
gWhereP2' :: AsLabel a -> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter x x
gWhereP2' :: forall a b x.
AsLabel a
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWhereP2' AsLabel a
start Greskell (LabeledP a)
p Maybe (ByProjection a b)
mby = Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
forall a b x.
Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWherePGeneric (AsLabel a -> Maybe (AsLabel a)
forall a. a -> Maybe a
Just AsLabel a
start) Greskell (LabeledP a)
p Maybe (ByProjection a b)
mby
data MatchResult
data MatchPattern where
MatchPattern :: AsLabel a -> Walk Transform a b -> MatchPattern
unsafePatternT :: MatchPattern -> GTraversal Transform () ()
unsafePatternT :: MatchPattern -> GTraversal Transform () ()
unsafePatternT (MatchPattern AsLabel a
l Walk Transform a b
w) = GTraversal Transform () b -> GTraversal Transform () ()
forall c s e1 e2.
WalkType c =>
GTraversal c s e1 -> GTraversal c s e2
forall (g :: * -> * -> * -> *) c s e1 e2.
(ToGTraversal g, WalkType c) =>
g c s e1 -> g c s e2
unsafeCastEnd (GTraversal Transform () b -> GTraversal Transform () ())
-> GTraversal Transform () b -> GTraversal Transform () ()
forall a b. (a -> b) -> a -> b
$ GTraversal Transform a b -> GTraversal Transform () b
forall c s1 e s2.
WalkType c =>
GTraversal c s1 e -> GTraversal c s2 e
forall (g :: * -> * -> * -> *) c s1 e s2.
(ToGTraversal g, WalkType c) =>
g c s1 e -> g c s2 e
unsafeCastStart (GTraversal Transform a b -> GTraversal Transform () b)
-> GTraversal Transform a b -> GTraversal Transform () b
forall a b. (a -> b) -> a -> b
$ Walk Transform a b -> GTraversal Transform a b
forall c s e. WalkType c => Walk c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal (AsLabel a -> Walk Transform a a
forall a. AsLabel a -> Walk Transform a a
gAs AsLabel a
l Walk Transform a a -> Walk Transform a b -> Walk Transform a b
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Walk Transform a b
w)
mPattern :: (WalkType c, Lift c Transform) => AsLabel a -> Walk c a b -> Logic MatchPattern
mPattern :: forall c a b.
(WalkType c, Lift c Transform) =>
AsLabel a -> Walk c a b -> Logic MatchPattern
mPattern AsLabel a
l Walk c a b
w = MatchPattern -> Logic MatchPattern
forall a. a -> Logic a
Logic.Leaf (MatchPattern -> Logic MatchPattern)
-> MatchPattern -> Logic MatchPattern
forall a b. (a -> b) -> a -> b
$ AsLabel a -> Walk Transform a b -> MatchPattern
forall a e. AsLabel a -> Walk Transform a e -> MatchPattern
MatchPattern AsLabel a
l (Walk c a b -> Walk Transform a b
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk Walk c a b
w)
gMatch :: Logic MatchPattern -> Walk Transform a MatchResult
gMatch :: forall a. Logic MatchPattern -> Walk Transform a MatchResult
gMatch Logic MatchPattern
patterns = Text -> [Text] -> Walk Transform a MatchResult
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"match" [Text]
args
where
args :: [Text]
args =
case Logic MatchPattern
patterns of
Logic.And Logic MatchPattern
p [Logic MatchPattern]
rest -> (Logic MatchPattern -> Text) -> [Logic MatchPattern] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (GTraversal Transform () () -> Text
forall a. ToGreskell a => a -> Text
toGremlin (GTraversal Transform () () -> Text)
-> (Logic MatchPattern -> GTraversal Transform () ())
-> Logic MatchPattern
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Logic MatchPattern -> GTraversal Transform () ()
toTraversal) (Logic MatchPattern
p Logic MatchPattern -> [Logic MatchPattern] -> [Logic MatchPattern]
forall a. a -> [a] -> [a]
: [Logic MatchPattern]
rest)
Logic MatchPattern
_ -> [GTraversal Transform () () -> Text
forall a. ToGreskell a => a -> Text
toGremlin (GTraversal Transform () () -> Text)
-> GTraversal Transform () () -> Text
forall a b. (a -> b) -> a -> b
$ Logic MatchPattern -> GTraversal Transform () ()
toTraversal Logic MatchPattern
patterns]
toTraversal :: Logic MatchPattern -> GTraversal Transform () ()
toTraversal Logic MatchPattern
l =
case Logic MatchPattern
l of
Logic.Leaf MatchPattern
p -> MatchPattern -> GTraversal Transform () ()
unsafePatternT MatchPattern
p
Logic.And Logic MatchPattern
p [Logic MatchPattern]
rest -> Walk Transform () () -> GTraversal Transform () ()
forall c s e. WalkType c => Walk c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal (Walk Transform () () -> GTraversal Transform () ())
-> Walk Transform () () -> GTraversal Transform () ()
forall a b. (a -> b) -> a -> b
$ [GTraversal Transform () ()] -> Walk Transform () ()
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gAnd ([GTraversal Transform () ()] -> Walk Transform () ())
-> [GTraversal Transform () ()] -> Walk Transform () ()
forall a b. (a -> b) -> a -> b
$ (Logic MatchPattern -> GTraversal Transform () ())
-> [Logic MatchPattern] -> [GTraversal Transform () ()]
forall a b. (a -> b) -> [a] -> [b]
map Logic MatchPattern -> GTraversal Transform () ()
toTraversal (Logic MatchPattern
p Logic MatchPattern -> [Logic MatchPattern] -> [Logic MatchPattern]
forall a. a -> [a] -> [a]
: [Logic MatchPattern]
rest)
Logic.Or Logic MatchPattern
p [Logic MatchPattern]
rest -> Walk Transform () () -> GTraversal Transform () ()
forall c s e. WalkType c => Walk c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal (Walk Transform () () -> GTraversal Transform () ())
-> Walk Transform () () -> GTraversal Transform () ()
forall a b. (a -> b) -> a -> b
$ [GTraversal Transform () ()] -> Walk Transform () ()
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gOr ([GTraversal Transform () ()] -> Walk Transform () ())
-> [GTraversal Transform () ()] -> Walk Transform () ()
forall a b. (a -> b) -> a -> b
$ (Logic MatchPattern -> GTraversal Transform () ())
-> [Logic MatchPattern] -> [GTraversal Transform () ()]
forall a b. (a -> b) -> [a] -> [b]
map Logic MatchPattern -> GTraversal Transform () ()
toTraversal (Logic MatchPattern
p Logic MatchPattern -> [Logic MatchPattern] -> [Logic MatchPattern]
forall a. a -> [a] -> [a]
: [Logic MatchPattern]
rest)
Logic.Not Logic MatchPattern
p -> Walk Transform () () -> GTraversal Transform () ()
forall c s e. WalkType c => Walk c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal (Walk Transform () () -> GTraversal Transform () ())
-> Walk Transform () () -> GTraversal Transform () ()
forall a b. (a -> b) -> a -> b
$ GTraversal Transform () () -> Walk Transform () ()
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gNot (GTraversal Transform () () -> Walk Transform () ())
-> GTraversal Transform () () -> Walk Transform () ()
forall a b. (a -> b) -> a -> b
$ Logic MatchPattern -> GTraversal Transform () ()
toTraversal Logic MatchPattern
p
gIs :: (WalkType c) => Greskell v -> Walk c v v
gIs :: forall c v. WalkType c => Greskell v -> Walk c v v
gIs = Walk Filter v v -> Walk c v v
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter v v -> Walk c v v)
-> (Greskell v -> Walk Filter v v) -> Greskell v -> Walk c v v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell v -> Walk Filter v v
forall v. Greskell v -> Walk Filter v v
gIs'
gIs' :: Greskell v -> Walk Filter v v
gIs' :: forall v. Greskell v -> Walk Filter v v
gIs' Greskell v
v = Text -> [Text] -> Walk Filter v v
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"is" [Greskell v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell v
v]
gIsP :: (WalkType c) => Greskell (P v) -> Walk c v v
gIsP :: forall c v. WalkType c => Greskell (P v) -> Walk c v v
gIsP = Walk Filter v v -> Walk c v v
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter v v -> Walk c v v)
-> (Greskell (P v) -> Walk Filter v v)
-> Greskell (P v)
-> Walk c v v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell (P v) -> Walk Filter v v
forall v. Greskell (P v) -> Walk Filter v v
gIsP'
gIsP' :: Greskell (P v) -> Walk Filter v v
gIsP' :: forall v. Greskell (P v) -> Walk Filter v v
gIsP' Greskell (P v)
p = Text -> [Text] -> Walk Filter v v
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"is" [Greskell (P v) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (P v)
p]
gHas1 :: (WalkType c, Element s)
=> Key s v
-> Walk c s s
gHas1 :: forall c s v. (WalkType c, Element s) => Key s v -> Walk c s s
gHas1 = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s)
-> (Key s v -> Walk Filter s s) -> Key s v -> Walk c s s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Key s v -> Walk Filter s s
forall s v. Element s => Key s v -> Walk Filter s s
gHas1'
gHas1' :: (Element s) => Key s v -> Walk Filter s s
gHas1' :: forall s v. Element s => Key s v -> Walk Filter s s
gHas1' Key s v
key = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"has" [Key s v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Key s v
key]
gHas2 :: (WalkType c, Element s) => Key s v -> Greskell v -> Walk c s s
gHas2 :: forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell v -> Walk c s s
gHas2 Key s v
k Greskell v
v = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s) -> Walk Filter s s -> Walk c s s
forall a b. (a -> b) -> a -> b
$ Key s v -> Greskell v -> Walk Filter s s
forall s v. Element s => Key s v -> Greskell v -> Walk Filter s s
gHas2' Key s v
k Greskell v
v
gHas2' :: (Element s) => Key s v -> Greskell v -> Walk Filter s s
gHas2' :: forall s v. Element s => Key s v -> Greskell v -> Walk Filter s s
gHas2' Key s v
k Greskell v
v = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"has" [Key s v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Key s v
k, Greskell v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell v
v]
gHas2P :: (WalkType c, Element s)
=> Key s v
-> Greskell (P v)
-> Walk c s s
gHas2P :: forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell (P v) -> Walk c s s
gHas2P Key s v
k Greskell (P v)
p = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s) -> Walk Filter s s -> Walk c s s
forall a b. (a -> b) -> a -> b
$ Key s v -> Greskell (P v) -> Walk Filter s s
forall s v.
Element s =>
Key s v -> Greskell (P v) -> Walk Filter s s
gHas2P' Key s v
k Greskell (P v)
p
gHas2P' :: (Element s) => Key s v -> Greskell (P v) -> Walk Filter s s
gHas2P' :: forall s v.
Element s =>
Key s v -> Greskell (P v) -> Walk Filter s s
gHas2P' Key s v
key Greskell (P v)
p = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"has" [Key s v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Key s v
key, Greskell (P v) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (P v)
p]
gHasLabel :: (Element s, WalkType c) => Greskell Text -> Walk c s s
gHasLabel :: forall s c. (Element s, WalkType c) => Greskell Text -> Walk c s s
gHasLabel = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s)
-> (Greskell Text -> Walk Filter s s)
-> Greskell Text
-> Walk c s s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell Text -> Walk Filter s s
forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel'
gHasLabel' :: (Element s) => Greskell Text -> Walk Filter s s
gHasLabel' :: forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
l = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasLabel" [Greskell Text -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Text
l]
gHasLabelP :: (Element s, WalkType c)
=> Greskell (P Text)
-> Walk c s s
gHasLabelP :: forall s c.
(Element s, WalkType c) =>
Greskell (P Text) -> Walk c s s
gHasLabelP = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s)
-> (Greskell (P Text) -> Walk Filter s s)
-> Greskell (P Text)
-> Walk c s s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell (P Text) -> Walk Filter s s
forall s. Element s => Greskell (P Text) -> Walk Filter s s
gHasLabelP'
gHasLabelP' :: Element s
=> Greskell (P Text)
-> Walk Filter s s
gHasLabelP' :: forall s. Element s => Greskell (P Text) -> Walk Filter s s
gHasLabelP' Greskell (P Text)
p = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasLabel" [Greskell (P Text) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (P Text)
p]
gHasId :: (Element s, WalkType c) => Greskell (ElementID s) -> Walk c s s
gHasId :: forall s c.
(Element s, WalkType c) =>
Greskell (ElementID s) -> Walk c s s
gHasId = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s)
-> (Greskell (ElementID s) -> Walk Filter s s)
-> Greskell (ElementID s)
-> Walk c s s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell (ElementID s) -> Walk Filter s s
forall s. Element s => Greskell (ElementID s) -> Walk Filter s s
gHasId'
gHasId' :: Element s => Greskell (ElementID s) -> Walk Filter s s
gHasId' :: forall s. Element s => Greskell (ElementID s) -> Walk Filter s s
gHasId' Greskell (ElementID s)
i = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasId" [Greskell (ElementID s) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (ElementID s)
i]
gHasIdP :: (Element s, WalkType c)
=> Greskell (P (ElementID s))
-> Walk c s s
gHasIdP :: forall s c.
(Element s, WalkType c) =>
Greskell (P (ElementID s)) -> Walk c s s
gHasIdP = Walk Filter s s -> Walk c s s
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter s s -> Walk c s s)
-> (Greskell (P (ElementID s)) -> Walk Filter s s)
-> Greskell (P (ElementID s))
-> Walk c s s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell (P (ElementID s)) -> Walk Filter s s
forall s.
Element s =>
Greskell (P (ElementID s)) -> Walk Filter s s
gHasIdP'
gHasIdP' :: Element s
=> Greskell (P (ElementID s))
-> Walk Filter s s
gHasIdP' :: forall s.
Element s =>
Greskell (P (ElementID s)) -> Walk Filter s s
gHasIdP' Greskell (P (ElementID s))
p = Text -> [Text] -> Walk Filter s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasId" [Greskell (P (ElementID s)) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (P (ElementID s))
p]
gHasKey :: (Element (p v), Property p, WalkType c) => Greskell Text -> Walk c (p v) (p v)
gHasKey :: forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell Text -> Walk c (p v) (p v)
gHasKey = Walk Filter (p v) (p v) -> Walk c (p v) (p v)
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter (p v) (p v) -> Walk c (p v) (p v))
-> (Greskell Text -> Walk Filter (p v) (p v))
-> Greskell Text
-> Walk c (p v) (p v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell Text -> Walk Filter (p v) (p v)
forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell Text -> Walk Filter (p v) (p v)
gHasKey'
gHasKey' :: (Element (p v), Property p) => Greskell Text -> Walk Filter (p v) (p v)
gHasKey' :: forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell Text -> Walk Filter (p v) (p v)
gHasKey' Greskell Text
k = Text -> [Text] -> Walk Filter (p v) (p v)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasKey" [Greskell Text -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Text
k]
gHasKeyP :: (Element (p v), Property p, WalkType c)
=> Greskell (P Text)
-> Walk c (p v) (p v)
gHasKeyP :: forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell (P Text) -> Walk c (p v) (p v)
gHasKeyP = Walk Filter (p v) (p v) -> Walk c (p v) (p v)
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter (p v) (p v) -> Walk c (p v) (p v))
-> (Greskell (P Text) -> Walk Filter (p v) (p v))
-> Greskell (P Text)
-> Walk c (p v) (p v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell (P Text) -> Walk Filter (p v) (p v)
forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell (P Text) -> Walk Filter (p v) (p v)
gHasKeyP'
gHasKeyP' :: (Element (p v), Property p) => Greskell (P Text) -> Walk Filter (p v) (p v)
gHasKeyP' :: forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell (P Text) -> Walk Filter (p v) (p v)
gHasKeyP' Greskell (P Text)
p = Text -> [Text] -> Walk Filter (p v) (p v)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasKey" [Greskell (P Text) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (P Text)
p]
gHasValue :: (Element (p v), Property p, WalkType c) => Greskell v -> Walk c (p v) (p v)
gHasValue :: forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell v -> Walk c (p v) (p v)
gHasValue = Walk Filter (p v) (p v) -> Walk c (p v) (p v)
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter (p v) (p v) -> Walk c (p v) (p v))
-> (Greskell v -> Walk Filter (p v) (p v))
-> Greskell v
-> Walk c (p v) (p v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell v -> Walk Filter (p v) (p v)
forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell v -> Walk Filter (p v) (p v)
gHasValue'
gHasValue' :: (Element (p v), Property p) => Greskell v -> Walk Filter (p v) (p v)
gHasValue' :: forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell v -> Walk Filter (p v) (p v)
gHasValue' Greskell v
v = Text -> [Text] -> Walk Filter (p v) (p v)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasValue" [Greskell v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell v
v]
gHasValueP :: (Element (p v), Property p, WalkType c)
=> Greskell (P v)
-> Walk c (p v) (p v)
gHasValueP :: forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell (P v) -> Walk c (p v) (p v)
gHasValueP = Walk Filter (p v) (p v) -> Walk c (p v) (p v)
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
Walk from s e -> Walk to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk (Walk Filter (p v) (p v) -> Walk c (p v) (p v))
-> (Greskell (P v) -> Walk Filter (p v) (p v))
-> Greskell (P v)
-> Walk c (p v) (p v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Greskell (P v) -> Walk Filter (p v) (p v)
forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell (P v) -> Walk Filter (p v) (p v)
gHasValueP'
gHasValueP' :: (Element (p v), Property p) => Greskell (P v) -> Walk Filter (p v) (p v)
gHasValueP' :: forall (p :: * -> *) v.
(Element (p v), Property p) =>
Greskell (P v) -> Walk Filter (p v) (p v)
gHasValueP' Greskell (P v)
p = Text -> [Text] -> Walk Filter (p v) (p v)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasValue" [Greskell (P v) -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell (P v)
p]
multiLogic :: (ToGTraversal g, WalkType c, WalkType p, Split c p)
=> Text
-> [g c s e]
-> Walk p s s
multiLogic :: forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
Text -> [g c s e] -> Walk p s s
multiLogic Text
method_name = Text -> [Text] -> Walk p s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
method_name ([Text] -> Walk p s s)
-> ([g c s e] -> [Text]) -> [g c s e] -> Walk p s s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (g c s e -> Text) -> [g c s e] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG
gAnd :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s
gAnd :: forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gAnd = Text -> [g c s e] -> Walk p s s
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
Text -> [g c s e] -> Walk p s s
multiLogic Text
"and"
gOr :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s
gOr :: forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gOr = Text -> [g c s e] -> Walk p s s
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
Text -> [g c s e] -> Walk p s s
multiLogic Text
"or"
gNot :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
gNot :: forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gNot g c s e
cond = Text -> [Text] -> Walk p s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"not" [g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s e
cond]
gRange :: Greskell Int
-> Greskell Int
-> Walk Transform s s
gRange :: forall s. Greskell Int -> Greskell Int -> Walk Transform s s
gRange Greskell Int
min_g Greskell Int
max_g = Text -> [Text] -> Walk Transform s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"range" ([Text] -> Walk Transform s s) -> [Text] -> Walk Transform s s
forall a b. (a -> b) -> a -> b
$ (Greskell Int -> Text) -> [Greskell Int] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Greskell Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin [Greskell Int
min_g, Greskell Int
max_g]
gLimit :: Greskell Int -> Walk Transform s s
gLimit :: forall s. Greskell Int -> Walk Transform s s
gLimit Greskell Int
num = Text -> [Text] -> Walk Transform s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"limit" [Greskell Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Int
num]
gTail :: Greskell Int -> Walk Transform s s
gTail :: forall s. Greskell Int -> Walk Transform s s
gTail Greskell Int
num = Text -> [Text] -> Walk Transform s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"tail" [Greskell Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Int
num]
gSkip :: Greskell Int -> Walk Transform s s
gSkip :: forall s. Greskell Int -> Walk Transform s s
gSkip Greskell Int
num = Text -> [Text] -> Walk Transform s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"skip" [Greskell Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Int
num]
newtype RepeatLabel
= RepeatLabel { RepeatLabel -> Text
unRepeatLabel :: Text }
deriving (RepeatLabel -> RepeatLabel -> Bool
(RepeatLabel -> RepeatLabel -> Bool)
-> (RepeatLabel -> RepeatLabel -> Bool) -> Eq RepeatLabel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepeatLabel -> RepeatLabel -> Bool
== :: RepeatLabel -> RepeatLabel -> Bool
$c/= :: RepeatLabel -> RepeatLabel -> Bool
/= :: RepeatLabel -> RepeatLabel -> Bool
Eq, String -> RepeatLabel
(String -> RepeatLabel) -> IsString RepeatLabel
forall a. (String -> a) -> IsString a
$cfromString :: String -> RepeatLabel
fromString :: String -> RepeatLabel
IsString, Eq RepeatLabel
Eq RepeatLabel =>
(RepeatLabel -> RepeatLabel -> Ordering)
-> (RepeatLabel -> RepeatLabel -> Bool)
-> (RepeatLabel -> RepeatLabel -> Bool)
-> (RepeatLabel -> RepeatLabel -> Bool)
-> (RepeatLabel -> RepeatLabel -> Bool)
-> (RepeatLabel -> RepeatLabel -> RepeatLabel)
-> (RepeatLabel -> RepeatLabel -> RepeatLabel)
-> Ord RepeatLabel
RepeatLabel -> RepeatLabel -> Bool
RepeatLabel -> RepeatLabel -> Ordering
RepeatLabel -> RepeatLabel -> RepeatLabel
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RepeatLabel -> RepeatLabel -> Ordering
compare :: RepeatLabel -> RepeatLabel -> Ordering
$c< :: RepeatLabel -> RepeatLabel -> Bool
< :: RepeatLabel -> RepeatLabel -> Bool
$c<= :: RepeatLabel -> RepeatLabel -> Bool
<= :: RepeatLabel -> RepeatLabel -> Bool
$c> :: RepeatLabel -> RepeatLabel -> Bool
> :: RepeatLabel -> RepeatLabel -> Bool
$c>= :: RepeatLabel -> RepeatLabel -> Bool
>= :: RepeatLabel -> RepeatLabel -> Bool
$cmax :: RepeatLabel -> RepeatLabel -> RepeatLabel
max :: RepeatLabel -> RepeatLabel -> RepeatLabel
$cmin :: RepeatLabel -> RepeatLabel -> RepeatLabel
min :: RepeatLabel -> RepeatLabel -> RepeatLabel
Ord, Int -> RepeatLabel -> ShowS
[RepeatLabel] -> ShowS
RepeatLabel -> String
(Int -> RepeatLabel -> ShowS)
-> (RepeatLabel -> String)
-> ([RepeatLabel] -> ShowS)
-> Show RepeatLabel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepeatLabel -> ShowS
showsPrec :: Int -> RepeatLabel -> ShowS
$cshow :: RepeatLabel -> String
show :: RepeatLabel -> String
$cshowList :: [RepeatLabel] -> ShowS
showList :: [RepeatLabel] -> ShowS
Show)
instance ToGreskell RepeatLabel where
type GreskellReturn RepeatLabel = Text
toGreskell :: RepeatLabel -> Greskell (GreskellReturn RepeatLabel)
toGreskell (RepeatLabel Text
t) = Text -> Greskell Text
Greskell.string Text
t
data RepeatPos
= RepeatHead
| RepeatTail
deriving (RepeatPos
RepeatPos -> RepeatPos -> Bounded RepeatPos
forall a. a -> a -> Bounded a
$cminBound :: RepeatPos
minBound :: RepeatPos
$cmaxBound :: RepeatPos
maxBound :: RepeatPos
Bounded, Int -> RepeatPos
RepeatPos -> Int
RepeatPos -> [RepeatPos]
RepeatPos -> RepeatPos
RepeatPos -> RepeatPos -> [RepeatPos]
RepeatPos -> RepeatPos -> RepeatPos -> [RepeatPos]
(RepeatPos -> RepeatPos)
-> (RepeatPos -> RepeatPos)
-> (Int -> RepeatPos)
-> (RepeatPos -> Int)
-> (RepeatPos -> [RepeatPos])
-> (RepeatPos -> RepeatPos -> [RepeatPos])
-> (RepeatPos -> RepeatPos -> [RepeatPos])
-> (RepeatPos -> RepeatPos -> RepeatPos -> [RepeatPos])
-> Enum RepeatPos
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: RepeatPos -> RepeatPos
succ :: RepeatPos -> RepeatPos
$cpred :: RepeatPos -> RepeatPos
pred :: RepeatPos -> RepeatPos
$ctoEnum :: Int -> RepeatPos
toEnum :: Int -> RepeatPos
$cfromEnum :: RepeatPos -> Int
fromEnum :: RepeatPos -> Int
$cenumFrom :: RepeatPos -> [RepeatPos]
enumFrom :: RepeatPos -> [RepeatPos]
$cenumFromThen :: RepeatPos -> RepeatPos -> [RepeatPos]
enumFromThen :: RepeatPos -> RepeatPos -> [RepeatPos]
$cenumFromTo :: RepeatPos -> RepeatPos -> [RepeatPos]
enumFromTo :: RepeatPos -> RepeatPos -> [RepeatPos]
$cenumFromThenTo :: RepeatPos -> RepeatPos -> RepeatPos -> [RepeatPos]
enumFromThenTo :: RepeatPos -> RepeatPos -> RepeatPos -> [RepeatPos]
Enum, RepeatPos -> RepeatPos -> Bool
(RepeatPos -> RepeatPos -> Bool)
-> (RepeatPos -> RepeatPos -> Bool) -> Eq RepeatPos
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepeatPos -> RepeatPos -> Bool
== :: RepeatPos -> RepeatPos -> Bool
$c/= :: RepeatPos -> RepeatPos -> Bool
/= :: RepeatPos -> RepeatPos -> Bool
Eq, Eq RepeatPos
Eq RepeatPos =>
(RepeatPos -> RepeatPos -> Ordering)
-> (RepeatPos -> RepeatPos -> Bool)
-> (RepeatPos -> RepeatPos -> Bool)
-> (RepeatPos -> RepeatPos -> Bool)
-> (RepeatPos -> RepeatPos -> Bool)
-> (RepeatPos -> RepeatPos -> RepeatPos)
-> (RepeatPos -> RepeatPos -> RepeatPos)
-> Ord RepeatPos
RepeatPos -> RepeatPos -> Bool
RepeatPos -> RepeatPos -> Ordering
RepeatPos -> RepeatPos -> RepeatPos
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RepeatPos -> RepeatPos -> Ordering
compare :: RepeatPos -> RepeatPos -> Ordering
$c< :: RepeatPos -> RepeatPos -> Bool
< :: RepeatPos -> RepeatPos -> Bool
$c<= :: RepeatPos -> RepeatPos -> Bool
<= :: RepeatPos -> RepeatPos -> Bool
$c> :: RepeatPos -> RepeatPos -> Bool
> :: RepeatPos -> RepeatPos -> Bool
$c>= :: RepeatPos -> RepeatPos -> Bool
>= :: RepeatPos -> RepeatPos -> Bool
$cmax :: RepeatPos -> RepeatPos -> RepeatPos
max :: RepeatPos -> RepeatPos -> RepeatPos
$cmin :: RepeatPos -> RepeatPos -> RepeatPos
min :: RepeatPos -> RepeatPos -> RepeatPos
Ord, Int -> RepeatPos -> ShowS
[RepeatPos] -> ShowS
RepeatPos -> String
(Int -> RepeatPos -> ShowS)
-> (RepeatPos -> String)
-> ([RepeatPos] -> ShowS)
-> Show RepeatPos
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepeatPos -> ShowS
showsPrec :: Int -> RepeatPos -> ShowS
$cshow :: RepeatPos -> String
show :: RepeatPos -> String
$cshowList :: [RepeatPos] -> ShowS
showList :: [RepeatPos] -> ShowS
Show)
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
deriving instance Show (RepeatUntil c s)
makeUntilWalk :: WalkType c => RepeatUntil c s -> Walk c s s
makeUntilWalk :: forall c s. WalkType c => RepeatUntil c s -> Walk c s s
makeUntilWalk (RepeatTimes Greskell Int
count) = Text -> [Text] -> Walk c s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"times" [Greskell Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Int
count]
makeUntilWalk (RepeatUntilT GTraversal cc s e
trav) = Text -> [Text] -> Walk c s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"until" [GTraversal cc s e -> Text
forall a. ToGreskell a => a -> Text
toGremlin GTraversal cc s e
trav]
data RepeatEmit c s where
RepeatEmit :: RepeatEmit c s
RepeatEmitT :: (WalkType cc, WalkType c, Split cc c) => GTraversal cc s e -> RepeatEmit c s
deriving instance Show (RepeatEmit c s)
makeEmitWalk :: WalkType c => RepeatEmit c s -> Walk c s s
makeEmitWalk :: forall c s. WalkType c => RepeatEmit c s -> Walk c s s
makeEmitWalk (RepeatEmit c s
RepeatEmit) = Text -> [Text] -> Walk c s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"emit" []
makeEmitWalk (RepeatEmitT GTraversal cc s e
trav) = Text -> [Text] -> Walk c s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"emit" [GTraversal cc s e -> Text
forall a. ToGreskell a => a -> Text
toGremlin GTraversal cc s e
trav]
newtype MWalk c s e
= MWalk (Maybe (Walk c s e))
deriving (Int -> MWalk c s e -> ShowS
[MWalk c s e] -> ShowS
MWalk c s e -> String
(Int -> MWalk c s e -> ShowS)
-> (MWalk c s e -> String)
-> ([MWalk c s e] -> ShowS)
-> Show (MWalk c s e)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall c s e. Int -> MWalk c s e -> ShowS
forall c s e. [MWalk c s e] -> ShowS
forall c s e. MWalk c s e -> String
$cshowsPrec :: forall c s e. Int -> MWalk c s e -> ShowS
showsPrec :: Int -> MWalk c s e -> ShowS
$cshow :: forall c s e. MWalk c s e -> String
show :: MWalk c s e -> String
$cshowList :: forall c s e. [MWalk c s e] -> ShowS
showList :: [MWalk c s e] -> ShowS
Show)
deriving instance WalkType c => Semigroup (MWalk c s s)
deriving instance WalkType c => Monoid (MWalk c s s)
toMWalk :: Walk c s e -> MWalk c s e
toMWalk :: forall c s e. Walk c s e -> MWalk c s e
toMWalk = Maybe (Walk c s e) -> MWalk c s e
forall c s e. Maybe (Walk c s e) -> MWalk c s e
MWalk (Maybe (Walk c s e) -> MWalk c s e)
-> (Walk c s e -> Maybe (Walk c s e)) -> Walk c s e -> MWalk c s e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Walk c s e -> Maybe (Walk c s e)
forall a. a -> Maybe a
Just
fromMWalk :: WalkType c => MWalk c s s -> Walk c s s
fromMWalk :: forall c s. WalkType c => MWalk c s s -> Walk c s s
fromMWalk (MWalk Maybe (Walk c s s)
Nothing) = Walk c s s
forall a. Monoid a => a
mempty
fromMWalk (MWalk (Just Walk c s s
w)) = Walk c s s
w
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
gRepeat :: forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
mlabel Maybe (RepeatPos, RepeatUntil c s)
muntil Maybe (RepeatPos, RepeatEmit c s)
memit g c s s
repeated_trav = MWalk c s s -> Walk c s s
forall c s. WalkType c => MWalk c s s -> Walk c s s
fromMWalk (MWalk c s s
head_walk MWalk c s s -> MWalk c s s -> MWalk c s s
forall a. Semigroup a => a -> a -> a
<> Walk c s s -> MWalk c s s
forall c s e. Walk c s e -> MWalk c s e
toMWalk Walk c s s
repeat_body MWalk c s s -> MWalk c s s -> MWalk c s s
forall a. Semigroup a => a -> a -> a
<> MWalk c s s
tail_walk)
where
repeat_body :: Walk c s s
repeat_body = Text -> [Text] -> Walk c s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"repeat" ([Text]
label_args [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [g c s s -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s s
repeated_trav])
label_args :: [Text]
label_args = [Text] -> (RepeatLabel -> [Text]) -> Maybe RepeatLabel -> [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\RepeatLabel
l -> [RepeatLabel -> Text
forall a. ToGreskell a => a -> Text
toGremlin RepeatLabel
l]) Maybe RepeatLabel
mlabel
head_walk :: MWalk c s s
head_walk = MWalk c s s
head_until MWalk c s s -> MWalk c s s -> MWalk c s s
forall a. Semigroup a => a -> a -> a
<> MWalk c s s
head_emit
tail_walk :: MWalk c s s
tail_walk = MWalk c s s
tail_until MWalk c s s -> MWalk c s s -> MWalk c s s
forall a. Semigroup a => a -> a -> a
<> MWalk c s s
tail_emit
(MWalk c s s
head_until, MWalk c s s
tail_until) =
case Maybe (RepeatPos, RepeatUntil c s)
muntil of
Maybe (RepeatPos, RepeatUntil c s)
Nothing -> (MWalk c s s
forall a. Monoid a => a
mempty, MWalk c s s
forall a. Monoid a => a
mempty)
Just (RepeatPos
pos, RepeatUntil c s
u) ->
case RepeatPos
pos of
RepeatPos
RepeatHead -> (Walk c s s -> MWalk c s s
forall c s e. Walk c s e -> MWalk c s e
toMWalk (Walk c s s -> MWalk c s s) -> Walk c s s -> MWalk c s s
forall a b. (a -> b) -> a -> b
$ RepeatUntil c s -> Walk c s s
forall c s. WalkType c => RepeatUntil c s -> Walk c s s
makeUntilWalk RepeatUntil c s
u, MWalk c s s
forall a. Monoid a => a
mempty)
RepeatPos
RepeatTail -> (MWalk c s s
forall a. Monoid a => a
mempty, Walk c s s -> MWalk c s s
forall c s e. Walk c s e -> MWalk c s e
toMWalk (Walk c s s -> MWalk c s s) -> Walk c s s -> MWalk c s s
forall a b. (a -> b) -> a -> b
$ RepeatUntil c s -> Walk c s s
forall c s. WalkType c => RepeatUntil c s -> Walk c s s
makeUntilWalk RepeatUntil c s
u)
(MWalk c s s
head_emit, MWalk c s s
tail_emit) =
case Maybe (RepeatPos, RepeatEmit c s)
memit of
Maybe (RepeatPos, RepeatEmit c s)
Nothing -> (MWalk c s s
forall a. Monoid a => a
mempty, MWalk c s s
forall a. Monoid a => a
mempty)
Just (RepeatPos
pos, RepeatEmit c s
e) ->
case RepeatPos
pos of
RepeatPos
RepeatHead -> (Walk c s s -> MWalk c s s
forall c s e. Walk c s e -> MWalk c s e
toMWalk (Walk c s s -> MWalk c s s) -> Walk c s s -> MWalk c s s
forall a b. (a -> b) -> a -> b
$ RepeatEmit c s -> Walk c s s
forall c s. WalkType c => RepeatEmit c s -> Walk c s s
makeEmitWalk RepeatEmit c s
e, MWalk c s s
forall a. Monoid a => a
mempty)
RepeatPos
RepeatTail -> (MWalk c s s
forall a. Monoid a => a
mempty, Walk c s s -> MWalk c s s
forall c s e. Walk c s e -> MWalk c s e
toMWalk (Walk c s s -> MWalk c s s) -> Walk c s s -> MWalk c s s
forall a b. (a -> b) -> a -> b
$ RepeatEmit c s -> Walk c s s
forall c s. WalkType c => RepeatEmit c s -> Walk c s s
makeEmitWalk RepeatEmit c s
e)
gTimes :: Greskell Int
-> Maybe (RepeatPos, RepeatUntil c s)
gTimes :: forall c s. Greskell Int -> Maybe (RepeatPos, RepeatUntil c s)
gTimes Greskell Int
c = (RepeatPos, RepeatUntil c s) -> Maybe (RepeatPos, RepeatUntil c s)
forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, Greskell Int -> RepeatUntil c s
forall c s. Greskell Int -> RepeatUntil c s
RepeatTimes Greskell Int
c)
gUntilHead :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
gUntilHead :: forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
gUntilHead g cc s e
trav = (RepeatPos, RepeatUntil c s) -> Maybe (RepeatPos, RepeatUntil c s)
forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, GTraversal cc s e -> RepeatUntil c s
forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatUntil c s
RepeatUntilT (GTraversal cc s e -> RepeatUntil c s)
-> GTraversal cc s e -> RepeatUntil c s
forall a b. (a -> b) -> a -> b
$ g cc s e -> GTraversal cc s e
forall c s e. WalkType c => g c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal g cc s e
trav)
gUntilTail :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
gUntilTail :: forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
gUntilTail g cc s e
trav = (RepeatPos, RepeatUntil c s) -> Maybe (RepeatPos, RepeatUntil c s)
forall a. a -> Maybe a
Just (RepeatPos
RepeatTail, GTraversal cc s e -> RepeatUntil c s
forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatUntil c s
RepeatUntilT (GTraversal cc s e -> RepeatUntil c s)
-> GTraversal cc s e -> RepeatUntil c s
forall a b. (a -> b) -> a -> b
$ g cc s e -> GTraversal cc s e
forall c s e. WalkType c => g c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal g cc s e
trav)
gEmitHead :: Maybe (RepeatPos, RepeatEmit c s)
gEmitHead :: forall c s. Maybe (RepeatPos, RepeatEmit c s)
gEmitHead = (RepeatPos, RepeatEmit c s) -> Maybe (RepeatPos, RepeatEmit c s)
forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, RepeatEmit c s
forall c s. RepeatEmit c s
RepeatEmit)
gEmitTail :: Maybe (RepeatPos, RepeatEmit c s)
gEmitTail :: forall c s. Maybe (RepeatPos, RepeatEmit c s)
gEmitTail = (RepeatPos, RepeatEmit c s) -> Maybe (RepeatPos, RepeatEmit c s)
forall a. a -> Maybe a
Just (RepeatPos
RepeatTail, RepeatEmit c s
forall c s. RepeatEmit c s
RepeatEmit)
gEmitHeadT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
gEmitHeadT :: forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
gEmitHeadT g cc s e
trav = (RepeatPos, RepeatEmit c s) -> Maybe (RepeatPos, RepeatEmit c s)
forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, GTraversal cc s e -> RepeatEmit c s
forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatEmit c s
RepeatEmitT (GTraversal cc s e -> RepeatEmit c s)
-> GTraversal cc s e -> RepeatEmit c s
forall a b. (a -> b) -> a -> b
$ g cc s e -> GTraversal cc s e
forall c s e. WalkType c => g c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal g cc s e
trav)
gEmitTailT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
gEmitTailT :: forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
gEmitTailT g cc s e
trav = (RepeatPos, RepeatEmit c s) -> Maybe (RepeatPos, RepeatEmit c s)
forall a. a -> Maybe a
Just (RepeatPos
RepeatTail, GTraversal cc s e -> RepeatEmit c s
forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatEmit c s
RepeatEmitT (GTraversal cc s e -> RepeatEmit c s)
-> GTraversal cc s e -> RepeatEmit c s
forall a b. (a -> b) -> a -> b
$ g cc s e -> GTraversal cc s e
forall c s e. WalkType c => g c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal g cc s e
trav)
gLoops :: Maybe RepeatLabel -> Walk Transform s Int
gLoops :: forall s. Maybe RepeatLabel -> Walk Transform s Int
gLoops Maybe RepeatLabel
mlabel = Text -> [Text] -> Walk Transform s Int
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"loops" ([Text] -> Walk Transform s Int) -> [Text] -> Walk Transform s Int
forall a b. (a -> b) -> a -> b
$ [Text] -> (RepeatLabel -> [Text]) -> Maybe RepeatLabel -> [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\RepeatLabel
l -> [RepeatLabel -> Text
forall a. ToGreskell a => a -> Text
toGremlin RepeatLabel
l]) Maybe RepeatLabel
mlabel
gLocal :: (ToGTraversal g, WalkType c) => g c s e -> Walk c s e
gLocal :: forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Walk c s e
gLocal g c s e
t = Text -> [Text] -> Walk c s e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"local" [g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s e
t]
gUnion :: (ToGTraversal g, WalkType c) => [g c s e] -> Walk c s e
gUnion :: forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
[g c s e] -> Walk c s e
gUnion [g c s e]
ts = Text -> [Text] -> Walk c s e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"union" ([Text] -> Walk c s e) -> [Text] -> Walk c s e
forall a b. (a -> b) -> a -> b
$ (g c s e -> Text) -> [g c s e] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG [g c s e]
ts
gCoalesce :: (ToGTraversal g, Split cc c, Lift Transform c, WalkType c, WalkType cc)
=> [g cc s e] -> Walk c s e
gCoalesce :: forall (g :: * -> * -> * -> *) cc c s e.
(ToGTraversal g, Split cc c, Lift Transform c, WalkType c,
WalkType cc) =>
[g cc s e] -> Walk c s e
gCoalesce [g cc s e]
ts = Text -> [Text] -> Walk c s e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"coalesce" ([Text] -> Walk c s e) -> [Text] -> Walk c s e
forall a b. (a -> b) -> a -> b
$ (g cc s e -> Text) -> [g cc s e] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map g cc s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG [g cc s e]
ts
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
gChoose3 :: forall (g :: * -> * -> * -> *) cc c s ep e.
(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
gChoose3 g cc s ep
pt g c s e
tt g c s e
ft = Text -> [Text] -> Walk c s e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"choose"
[ g cc s ep -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g cc s ep
pt,
g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s e
tt,
g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s e
ft
]
gBarrier :: WalkType c
=> Maybe (Greskell Int)
-> Walk c s s
gBarrier :: forall c s. WalkType c => Maybe (Greskell Int) -> Walk c s s
gBarrier Maybe (Greskell Int)
mmax = Text -> [Text] -> Walk c s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"barrier" ([Text] -> Walk c s s) -> [Text] -> Walk c s s
forall a b. (a -> b) -> a -> b
$ [Text]
-> (Greskell Int -> [Text]) -> Maybe (Greskell Int) -> [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Greskell Int
m -> [Greskell Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Int
m]) Maybe (Greskell Int)
mmax
gDedup :: Maybe (ByProjection s e)
-> Walk Transform s s
gDedup :: forall s e. Maybe (ByProjection s e) -> Walk Transform s s
gDedup Maybe (ByProjection s e)
mp = [Text] -> Maybe (ByProjection s e) -> Walk Transform s s
forall a b s.
[Text] -> Maybe (ByProjection a b) -> Walk Transform s s
gDedupGeneric [] Maybe (ByProjection s e)
mp
gDedupN :: AsLabel a -> [AsLabel a] -> Maybe (ByProjection a e) -> Walk Transform s s
gDedupN :: forall a e s.
AsLabel a
-> [AsLabel a] -> Maybe (ByProjection a e) -> Walk Transform s s
gDedupN AsLabel a
l [AsLabel a]
ls Maybe (ByProjection a e)
mp = [Text] -> Maybe (ByProjection a e) -> Walk Transform s s
forall a b s.
[Text] -> Maybe (ByProjection a b) -> Walk Transform s s
gDedupGeneric ((AsLabel a -> Text) -> [AsLabel a] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map AsLabel a -> Text
forall a. ToGreskell a => a -> Text
toGremlin (AsLabel a
l AsLabel a -> [AsLabel a] -> [AsLabel a]
forall a. a -> [a] -> [a]
: [AsLabel a]
ls)) Maybe (ByProjection a e)
mp
gDedupGeneric :: [Text] -> Maybe (ByProjection a b) -> Walk Transform s s
gDedupGeneric :: forall a b s.
[Text] -> Maybe (ByProjection a b) -> Walk Transform s s
gDedupGeneric [Text]
args Maybe (ByProjection a b)
mp =
case Maybe (ByProjection a b)
mp of
Maybe (ByProjection a b)
Nothing -> Walk Transform s s
main_walk
Just (ByProjection p
g) -> Walk Transform s s -> [Walk Transform s s] -> Walk Transform s s
forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith Walk Transform s s
main_walk [Text -> [Text] -> Walk Transform s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [p -> Text
forall a. ToGreskell a => a -> Text
toGremlin p
g]]
where
main_walk :: Walk Transform s s
main_walk = Text -> [Text] -> Walk Transform s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"dedup" [Text]
args
class ProjectionLike p where
type ProjectionLikeStart p
type ProjectionLikeEnd p
instance ProjectionLike (Walk Filter s e) where
type ProjectionLikeStart (Walk Filter s e) = s
type ProjectionLikeEnd (Walk Filter s e) = e
instance ProjectionLike (GTraversal Filter s e) where
type ProjectionLikeStart (GTraversal Filter s e) = s
type ProjectionLikeEnd (GTraversal Filter s e) = e
instance ProjectionLike (Greskell (GraphTraversal Filter s e)) where
type ProjectionLikeStart (Greskell (GraphTraversal Filter s e)) = s
type ProjectionLikeEnd (Greskell (GraphTraversal Filter s e)) = e
instance ProjectionLike (Walk Transform s e) where
type ProjectionLikeStart (Walk Transform s e) = s
type ProjectionLikeEnd (Walk Transform s e) = e
instance ProjectionLike (GTraversal Transform s e) where
type ProjectionLikeStart (GTraversal Transform s e) = s
type ProjectionLikeEnd (GTraversal Transform s e) = e
instance ProjectionLike (Greskell (GraphTraversal Transform s e)) where
type ProjectionLikeStart (Greskell (GraphTraversal Transform s e)) = s
type ProjectionLikeEnd (Greskell (GraphTraversal Transform s e)) = e
instance ProjectionLike (Key s e) where
type ProjectionLikeStart (Key s e) = s
type ProjectionLikeEnd (Key s e) = e
instance ProjectionLike (Greskell (T s e)) where
type ProjectionLikeStart (Greskell (T s e)) = s
type ProjectionLikeEnd (Greskell (T s e)) = e
instance ProjectionLike (Greskell (s -> e)) where
type ProjectionLikeStart (Greskell (s -> e)) = s
type ProjectionLikeEnd (Greskell (s -> e)) = e
instance ProjectionLike (ByProjection s e) where
type ProjectionLikeStart (ByProjection s e) = s
type ProjectionLikeEnd (ByProjection s e) = e
data ByProjection s e where
ByProjection :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
instance IsString (ByProjection s e) where
fromString :: String -> ByProjection s e
fromString = Key s e -> ByProjection s e
Key s e
-> ByProjection
(ProjectionLikeStart (Key s e)) (ProjectionLikeEnd (Key s e))
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
ByProjection (Key s e -> ByProjection s e)
-> (String -> Key s e) -> String -> ByProjection s e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Key s e
forall s e. String -> Key s e
toKey
where
toKey :: String -> Key s e
toKey :: forall s e. String -> Key s e
toKey = String -> Key s e
forall a. IsString a => String -> a
fromString
gBy :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
gBy :: forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy = p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
ByProjection
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
instance IsString (ByComparator s) where
fromString :: String -> ByComparator s
fromString = ByProjection s Any -> ByComparator s
forall s a. ByProjection s a -> ByComparator s
ByComparatorProj (ByProjection s Any -> ByComparator s)
-> (String -> ByProjection s Any) -> String -> ByComparator s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByProjection s Any
forall a. IsString a => String -> a
fromString
gBy1 :: (ProjectionLike p, ToGreskell p) => p -> ByComparator (ProjectionLikeStart p)
gBy1 :: forall p.
(ProjectionLike p, ToGreskell p) =>
p -> ByComparator (ProjectionLikeStart p)
gBy1 = ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
-> ByComparator (ProjectionLikeStart p)
forall s a. ByProjection s a -> ByComparator s
ByComparatorProj (ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
-> ByComparator (ProjectionLikeStart p))
-> (p
-> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p))
-> p
-> ByComparator (ProjectionLikeStart p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy
gBy2 :: (ProjectionLike p, ToGreskell p, Comparator comp, ProjectionLikeEnd p ~ CompareArg comp)
=> p
-> Greskell comp
-> ByComparator (ProjectionLikeStart p)
gBy2 :: forall p comp.
(ProjectionLike p, ToGreskell p, Comparator comp,
ProjectionLikeEnd p ~ CompareArg comp) =>
p -> Greskell comp -> ByComparator (ProjectionLikeStart p)
gBy2 p
p Greskell comp
c = ByProjection (ProjectionLikeStart p) (CompareArg comp)
-> Greskell comp -> ByComparator (ProjectionLikeStart p)
forall a s.
Comparator a =>
ByProjection s (CompareArg a) -> Greskell a -> ByComparator s
ByComparatorProjComp (p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy p
p) Greskell comp
c
gOrder :: [ByComparator s]
-> Walk Transform s s
gOrder :: forall s. [ByComparator s] -> Walk Transform s s
gOrder [ByComparator s]
bys = Walk Transform s s -> [Walk Transform s s] -> Walk Transform s s
forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith Walk Transform s s
forall {s} {e}. Walk Transform s e
order_step [Walk Transform s s]
by_steps
where
order_step :: Walk Transform s e
order_step = Text -> [Text] -> Walk Transform s e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"order" []
by_steps :: [Walk Transform s s]
by_steps = (ByComparator s -> Walk Transform s s)
-> [ByComparator s] -> [Walk Transform s s]
forall a b. (a -> b) -> [a] -> [b]
map (Text -> [Text] -> Walk Transform s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" ([Text] -> Walk Transform s s)
-> (ByComparator s -> [Text])
-> ByComparator s
-> Walk Transform s s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByComparator s -> [Text]
forall s. ByComparator s -> [Text]
toByArgs) [ByComparator s]
bys
toByArgs :: ByComparator s -> [Text]
toByArgs :: forall s. ByComparator s -> [Text]
toByArgs ByComparator s
bc = case ByComparator s
bc of
ByComparatorProj (ByProjection p
p) -> [p -> Text
forall a. ToGreskell a => a -> Text
toGremlin p
p]
ByComparatorComp Greskell comp
comp -> [Greskell comp -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell comp
comp]
ByComparatorProjComp (ByProjection p
p) Greskell comp
comp -> [p -> Text
forall a. ToGreskell a => a -> Text
toGremlin p
p, Greskell comp -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell comp
comp]
data LabeledByProjection s where
LabeledByProjection :: AsLabel a -> ByProjection s a -> LabeledByProjection s
gByL :: (ProjectionLike p, ToGreskell p) => AsLabel (ProjectionLikeEnd p) -> p -> LabeledByProjection (ProjectionLikeStart p)
gByL :: forall p.
(ProjectionLike p, ToGreskell p) =>
AsLabel (ProjectionLikeEnd p)
-> p -> LabeledByProjection (ProjectionLikeStart p)
gByL AsLabel (ProjectionLikeEnd p)
l p
p = AsLabel (ProjectionLikeEnd p)
-> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
-> LabeledByProjection (ProjectionLikeStart p)
forall a s. AsLabel a -> ByProjection s a -> LabeledByProjection s
LabeledByProjection AsLabel (ProjectionLikeEnd p)
l (ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
-> LabeledByProjection (ProjectionLikeStart p))
-> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
-> LabeledByProjection (ProjectionLikeStart p)
forall a b. (a -> b) -> a -> b
$ p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy p
p
gFlatMap :: (Lift Transform c, Split cc c, ToGTraversal g, WalkType c, WalkType cc) => g cc s e -> Walk c s e
gFlatMap :: forall c cc (g :: * -> * -> * -> *) s e.
(Lift Transform c, Split cc c, ToGTraversal g, WalkType c,
WalkType cc) =>
g cc s e -> Walk c s e
gFlatMap g cc s e
gt = Text -> [Text] -> Walk c s e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"flatMap" [g cc s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g cc s e
gt]
gFlatMap' :: ToGTraversal g => g Transform s e -> Walk Transform s e
gFlatMap' :: forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> Walk Transform s e
gFlatMap' g Transform s e
gt = g Transform s e -> Walk Transform s e
forall c cc (g :: * -> * -> * -> *) s e.
(Lift Transform c, Split cc c, ToGTraversal g, WalkType c,
WalkType cc) =>
g cc s e -> Walk c s e
gFlatMap g Transform s e
gt
gV :: Vertex v => [Greskell (ElementID v)] -> Walk Transform s v
gV :: forall v s.
Vertex v =>
[Greskell (ElementID v)] -> Walk Transform s v
gV [Greskell (ElementID v)]
ids = Text -> [Text] -> Walk Transform s v
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"V" ([Text] -> Walk Transform s v) -> [Text] -> Walk Transform s v
forall a b. (a -> b) -> a -> b
$ (Greskell (ElementID v) -> Text)
-> [Greskell (ElementID v)] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Greskell (ElementID v) -> Text
forall a. ToGreskell a => a -> Text
toGremlin [Greskell (ElementID v)]
ids
gV' :: [Greskell (ElementID AVertex)] -> Walk Transform s AVertex
gV' :: forall s.
[Greskell (ElementID AVertex)] -> Walk Transform s AVertex
gV' = [Greskell (ElementID AVertex)] -> Walk Transform s AVertex
forall v s.
Vertex v =>
[Greskell (ElementID v)] -> Walk Transform s v
gV
gConstant :: Greskell a -> Walk Transform s a
gConstant :: forall a s. Greskell a -> Walk Transform s a
gConstant Greskell a
v = Text -> [Text] -> Walk Transform s a
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"constant" [Greskell a -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell a
v]
gUnfold :: AsIterator a => Walk Transform a (IteratorItem a)
gUnfold :: forall a. AsIterator a => Walk Transform a (IteratorItem a)
gUnfold = Text -> [Text] -> Walk Transform a (IteratorItem a)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"unfold" []
gAs :: AsLabel a -> Walk Transform a a
gAs :: forall a. AsLabel a -> Walk Transform a a
gAs AsLabel a
l = Text -> [Text] -> Walk Transform a a
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"as" [AsLabel a -> Text
forall a. ToGreskell a => a -> Text
toGremlin AsLabel a
l]
gValues :: Element s
=> [Key s e]
-> Walk Transform s e
gValues :: forall s e. Element s => [Key s e] -> Walk Transform s e
gValues = Text -> [Text] -> Walk Transform s e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"values" ([Text] -> Walk Transform s e)
-> ([Key s e] -> [Text]) -> [Key s e] -> Walk Transform s e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key s e -> Text) -> [Key s e] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Key s e -> Text
forall a. ToGreskell a => a -> Text
toGremlin
gProperties :: (Element s, Property p, ElementProperty s ~ p)
=> [Key s v]
-> Walk Transform s (p v)
gProperties :: forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties = Text -> [Text] -> Walk Transform s (p v)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"properties" ([Text] -> Walk Transform s (p v))
-> ([Key s v] -> [Text]) -> [Key s v] -> Walk Transform s (p v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key s v -> Text) -> [Key s v] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Key s v -> Text
forall a. ToGreskell a => a -> Text
toGremlin
gId :: Element s => Walk Transform s (ElementID s)
gId :: forall s. Element s => Walk Transform s (ElementID s)
gId = Text -> [Text] -> Walk Transform s (ElementID s)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"id" []
gLabel :: Element s => Walk Transform s Text
gLabel :: forall s. Element s => Walk Transform s Text
gLabel = Text -> [Text] -> Walk Transform s Text
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"label" []
gValueMap :: Element s
=> Keys s
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
gValueMap :: forall s.
Element s =>
Keys s
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
gValueMap Keys s
keys = Text
-> [Text]
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"valueMap" ([Text]
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue))
-> [Text]
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
forall a b. (a -> b) -> a -> b
$ Keys s -> [Text]
forall a. Keys a -> [Text]
toGremlinKeys Keys s
keys
gElementMap :: Element s
=> Keys s
-> Walk Transform s (PMap Single GValue)
gElementMap :: forall s.
Element s =>
Keys s -> Walk Transform s (SelectedMap GValue)
gElementMap Keys s
keys = Text -> [Text] -> Walk Transform s (SelectedMap GValue)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"elementMap" ([Text] -> Walk Transform s (SelectedMap GValue))
-> [Text] -> Walk Transform s (SelectedMap GValue)
forall a b. (a -> b) -> a -> b
$ Keys s -> [Text]
forall a. Keys a -> [Text]
toGremlinKeys Keys s
keys
gSelect1 :: AsLabel a -> Walk Transform s a
gSelect1 :: forall a s. AsLabel a -> Walk Transform s a
gSelect1 AsLabel a
l = Text -> [Text] -> Walk Transform s a
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"select" [AsLabel a -> Text
forall a. ToGreskell a => a -> Text
toGremlin AsLabel a
l]
gSelectN :: AsLabel a -> AsLabel b -> [AsLabel c] -> Walk Transform s (SelectedMap GValue)
gSelectN :: forall a b c s.
AsLabel a
-> AsLabel b
-> [AsLabel c]
-> Walk Transform s (SelectedMap GValue)
gSelectN AsLabel a
l1 AsLabel b
l2 [AsLabel c]
ls = Text -> [Text] -> Walk Transform s (SelectedMap GValue)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"select" ([AsLabel a -> Text
forall a. ToGreskell a => a -> Text
toGremlin AsLabel a
l1, AsLabel b -> Text
forall a. ToGreskell a => a -> Text
toGremlin AsLabel b
l2] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ (AsLabel c -> Text) -> [AsLabel c] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map AsLabel c -> Text
forall a. ToGreskell a => a -> Text
toGremlin [AsLabel c]
ls)
unsafeChangeEnd :: Walk c a b -> Walk c a b'
unsafeChangeEnd :: forall c a b b'. Walk c a b -> Walk c a b'
unsafeChangeEnd (Walk Text
t) = Text -> Walk c a b'
forall c s e. Text -> Walk c s e
Walk Text
t
byStep :: WalkType t => ByProjection a b -> Walk t c c
byStep :: forall t a b c. WalkType t => ByProjection a b -> Walk t c c
byStep (ByProjection p
p) = Text -> [Text] -> Walk t c c
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [p -> Text
forall a. ToGreskell a => a -> Text
toGremlin p
p]
gSelectBy1 :: AsLabel a -> ByProjection a b -> Walk Transform s b
gSelectBy1 :: forall a b s. AsLabel a -> ByProjection a b -> Walk Transform s b
gSelectBy1 AsLabel a
l ByProjection a b
bp = Walk Transform s b -> [Walk Transform b b] -> Walk Transform s b
forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (Walk Transform s a -> Walk Transform s b
forall c a b b'. Walk c a b -> Walk c a b'
unsafeChangeEnd (Walk Transform s a -> Walk Transform s b)
-> Walk Transform s a -> Walk Transform s b
forall a b. (a -> b) -> a -> b
$ AsLabel a -> Walk Transform s a
forall a s. AsLabel a -> Walk Transform s a
gSelect1 AsLabel a
l) [ByProjection a b -> Walk Transform b b
forall t a b c. WalkType t => ByProjection a b -> Walk t c c
byStep ByProjection a b
bp]
gSelectByN :: AsLabel a -> AsLabel a -> [AsLabel a] -> ByProjection a b -> Walk Transform s (SelectedMap b)
gSelectByN :: forall a b s.
AsLabel a
-> AsLabel a
-> [AsLabel a]
-> ByProjection a b
-> Walk Transform s (SelectedMap b)
gSelectByN AsLabel a
l1 AsLabel a
l2 [AsLabel a]
ls ByProjection a b
bp = Walk Transform s (SelectedMap b)
-> [Walk Transform (SelectedMap b) (SelectedMap b)]
-> Walk Transform s (SelectedMap b)
forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (Walk Transform s (SelectedMap GValue)
-> Walk Transform s (SelectedMap b)
forall c a b b'. Walk c a b -> Walk c a b'
unsafeChangeEnd (Walk Transform s (SelectedMap GValue)
-> Walk Transform s (SelectedMap b))
-> Walk Transform s (SelectedMap GValue)
-> Walk Transform s (SelectedMap b)
forall a b. (a -> b) -> a -> b
$ AsLabel a
-> AsLabel a
-> [AsLabel a]
-> Walk Transform s (SelectedMap GValue)
forall a b c s.
AsLabel a
-> AsLabel b
-> [AsLabel c]
-> Walk Transform s (SelectedMap GValue)
gSelectN AsLabel a
l1 AsLabel a
l2 [AsLabel a]
ls) [ByProjection a b -> Walk Transform (SelectedMap b) (SelectedMap b)
forall t a b c. WalkType t => ByProjection a b -> Walk t c c
byStep ByProjection a b
bp]
gProject :: LabeledByProjection s -> [LabeledByProjection s] -> Walk Transform s (PMap Single GValue)
gProject :: forall s.
LabeledByProjection s
-> [LabeledByProjection s] -> Walk Transform s (SelectedMap GValue)
gProject LabeledByProjection s
lp_head [LabeledByProjection s]
lps = (Walk Transform s (SelectedMap GValue)
-> LabeledByProjection s -> Walk Transform s (SelectedMap GValue))
-> Walk Transform s (SelectedMap GValue)
-> [LabeledByProjection s]
-> Walk Transform s (SelectedMap GValue)
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Walk Transform s (SelectedMap GValue)
-> LabeledByProjection s -> Walk Transform s (SelectedMap GValue)
forall {a} {c} {s}.
Walk Transform a c -> LabeledByProjection s -> Walk Transform a c
f (Text -> [Text] -> Walk Transform s (SelectedMap GValue)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"project" [Text]
labels) (LabeledByProjection s
lp_head LabeledByProjection s
-> [LabeledByProjection s] -> [LabeledByProjection s]
forall a. a -> [a] -> [a]
: [LabeledByProjection s]
lps)
where
labels :: [Text]
labels = (LabeledByProjection s -> Text)
-> [LabeledByProjection s] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map LabeledByProjection s -> Text
forall {s}. LabeledByProjection s -> Text
toLabelGremlin (LabeledByProjection s
lp_head LabeledByProjection s
-> [LabeledByProjection s] -> [LabeledByProjection s]
forall a. a -> [a] -> [a]
: [LabeledByProjection s]
lps)
toLabelGremlin :: LabeledByProjection s -> Text
toLabelGremlin (LabeledByProjection AsLabel a
l ByProjection s a
_) = AsLabel a -> Text
forall a. ToGreskell a => a -> Text
toGremlin AsLabel a
l
f :: Walk Transform a c -> LabeledByProjection s -> Walk Transform a c
f Walk Transform a c
acc LabeledByProjection s
lp = Walk Transform a c
acc Walk Transform a c -> Walk Transform c c -> Walk Transform a c
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> LabeledByProjection s -> Walk Transform c c
forall s a. LabeledByProjection s -> Walk Transform a a
toByStep LabeledByProjection s
lp
toByStep :: LabeledByProjection s -> Walk Transform a a
toByStep :: forall s a. LabeledByProjection s -> Walk Transform a a
toByStep (LabeledByProjection AsLabel a
_ (ByProjection p
p)) = Text -> [Text] -> Walk Transform a a
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [p -> Text
forall a. ToGreskell a => a -> Text
toGremlin p
p]
gPath :: Walk Transform s (Path GValue)
gPath :: forall s. Walk Transform s (Path GValue)
gPath = Text -> [Text] -> Walk Transform s (Path GValue)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"path" []
gPathBy :: ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b)
gPathBy :: forall a b s.
ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b)
gPathBy ByProjection a b
b1 [ByProjection a b]
bn = Walk Transform s (Path b)
-> [Walk Transform (Path b) (Path b)] -> Walk Transform s (Path b)
forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (Text -> [Text] -> Walk Transform s (Path b)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"path" []) ([Walk Transform (Path b) (Path b)] -> Walk Transform s (Path b))
-> [Walk Transform (Path b) (Path b)] -> Walk Transform s (Path b)
forall a b. (a -> b) -> a -> b
$ (ByProjection a b -> Walk Transform (Path b) (Path b))
-> [ByProjection a b] -> [Walk Transform (Path b) (Path b)]
forall a b. (a -> b) -> [a] -> [b]
map ByProjection a b -> Walk Transform (Path b) (Path b)
forall t a b c. WalkType t => ByProjection a b -> Walk t c c
byStep ([ByProjection a b] -> [Walk Transform (Path b) (Path b)])
-> [ByProjection a b] -> [Walk Transform (Path b) (Path b)]
forall a b. (a -> b) -> a -> b
$ ByProjection a b
b1 ByProjection a b -> [ByProjection a b] -> [ByProjection a b]
forall a. a -> [a] -> [a]
: [ByProjection a b]
bn
gFold :: Walk Transform a [a]
gFold :: forall a. Walk Transform a [a]
gFold = Text -> [Text] -> Walk Transform a [a]
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"fold" []
gCount :: Walk Transform a Int
gCount :: forall a. Walk Transform a Int
gCount = Text -> [Text] -> Walk Transform a Int
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"count" []
genericTraversalWalk :: Vertex v => Text -> [Greskell Text] -> Walk Transform v e
genericTraversalWalk :: forall v e.
Vertex v =>
Text -> [Greskell Text] -> Walk Transform v e
genericTraversalWalk Text
method_name = Text -> [Text] -> Walk Transform v e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
method_name ([Text] -> Walk Transform v e)
-> ([Greskell Text] -> [Text])
-> [Greskell Text]
-> Walk Transform v e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Greskell Text -> Text) -> [Greskell Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Greskell Text -> Text
forall a. ToGreskell a => a -> Text
toGremlin
gOut :: (Vertex v1, Vertex v2)
=> [Greskell Text]
-> Walk Transform v1 v2
gOut :: forall v1 v2.
(Vertex v1, Vertex v2) =>
[Greskell Text] -> Walk Transform v1 v2
gOut = Text -> [Greskell Text] -> Walk Transform v1 v2
forall v e.
Vertex v =>
Text -> [Greskell Text] -> Walk Transform v e
genericTraversalWalk Text
"out"
gOut' :: (Vertex v)
=> [Greskell Text]
-> Walk Transform v AVertex
gOut' :: forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' = [Greskell Text] -> Walk Transform v AVertex
forall v1 v2.
(Vertex v1, Vertex v2) =>
[Greskell Text] -> Walk Transform v1 v2
gOut
gOutE :: (Vertex v, Edge e)
=> [Greskell Text]
-> Walk Transform v e
gOutE :: forall v e.
(Vertex v, Edge e) =>
[Greskell Text] -> Walk Transform v e
gOutE = Text -> [Greskell Text] -> Walk Transform v e
forall v e.
Vertex v =>
Text -> [Greskell Text] -> Walk Transform v e
genericTraversalWalk Text
"outE"
gOutE' :: (Vertex v)
=> [Greskell Text]
-> Walk Transform v AEdge
gOutE' :: forall v. Vertex v => [Greskell Text] -> Walk Transform v AEdge
gOutE' = [Greskell Text] -> Walk Transform v AEdge
forall v e.
(Vertex v, Edge e) =>
[Greskell Text] -> Walk Transform v e
gOutE
gOutV :: (Edge e, Vertex v) => Walk Transform e v
gOutV :: forall e v. (Edge e, Vertex v) => Walk Transform e v
gOutV = Text -> [Text] -> Walk Transform e v
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"outV" []
gOutV' :: Edge e => Walk Transform e AVertex
gOutV' :: forall e. Edge e => Walk Transform e AVertex
gOutV' = Walk Transform e AVertex
forall e v. (Edge e, Vertex v) => Walk Transform e v
gOutV
gIn :: (Vertex v1, Vertex v2)
=> [Greskell Text]
-> Walk Transform v1 v2
gIn :: forall v1 v2.
(Vertex v1, Vertex v2) =>
[Greskell Text] -> Walk Transform v1 v2
gIn = Text -> [Greskell Text] -> Walk Transform v1 v2
forall v e.
Vertex v =>
Text -> [Greskell Text] -> Walk Transform v e
genericTraversalWalk Text
"in"
gIn' :: (Vertex v)
=> [Greskell Text]
-> Walk Transform v AVertex
gIn' :: forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gIn' = [Greskell Text] -> Walk Transform v AVertex
forall v1 v2.
(Vertex v1, Vertex v2) =>
[Greskell Text] -> Walk Transform v1 v2
gIn
gInE :: (Vertex v, Edge e)
=> [Greskell Text]
-> Walk Transform v e
gInE :: forall v e.
(Vertex v, Edge e) =>
[Greskell Text] -> Walk Transform v e
gInE = Text -> [Greskell Text] -> Walk Transform v e
forall v e.
Vertex v =>
Text -> [Greskell Text] -> Walk Transform v e
genericTraversalWalk Text
"inE"
gInE' :: (Vertex v)
=> [Greskell Text]
-> Walk Transform v AEdge
gInE' :: forall v. Vertex v => [Greskell Text] -> Walk Transform v AEdge
gInE' = [Greskell Text] -> Walk Transform v AEdge
forall v e.
(Vertex v, Edge e) =>
[Greskell Text] -> Walk Transform v e
gInE
gInV :: (Edge e, Vertex v) => Walk Transform e v
gInV :: forall e v. (Edge e, Vertex v) => Walk Transform e v
gInV = Text -> [Text] -> Walk Transform e v
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"inV" []
gInV' :: Edge e => Walk Transform e AVertex
gInV' :: forall e. Edge e => Walk Transform e AVertex
gInV' = Walk Transform e AVertex
forall e v. (Edge e, Vertex v) => Walk Transform e v
gInV
gSideEffect :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
gSideEffect :: forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gSideEffect g c s e
walk = Text -> [Text] -> Walk p s s
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"sideEffect" [g c s e -> Text
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s e
walk]
gSideEffect' :: (ToGTraversal g, WalkType c, Split c SideEffect) => g c s e -> Walk SideEffect s s
gSideEffect' :: forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c, Split c SideEffect) =>
g c s e -> Walk SideEffect s s
gSideEffect' g c s e
w = g c s e -> Walk SideEffect s s
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gSideEffect g c s e
w
gAddV :: Vertex v => Greskell Text -> Walk SideEffect a v
gAddV :: forall v a. Vertex v => Greskell Text -> Walk SideEffect a v
gAddV Greskell Text
label = Text -> [Text] -> Walk SideEffect a v
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"addV" [Greskell Text -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Text
label]
gAddV' :: Greskell Text -> Walk SideEffect a AVertex
gAddV' :: forall a. Greskell Text -> Walk SideEffect a AVertex
gAddV' = Greskell Text -> Walk SideEffect a AVertex
forall v a. Vertex v => Greskell Text -> Walk SideEffect a v
gAddV
gDrop :: Element e => Walk SideEffect e e
gDrop :: forall e. Element e => Walk SideEffect e e
gDrop = Text -> [Text] -> Walk SideEffect e e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"drop" []
gDropP :: Property p => Walk SideEffect (p a) (p a)
gDropP :: forall (p :: * -> *) a. Property p => Walk SideEffect (p a) (p a)
gDropP = Text -> [Text] -> Walk SideEffect (p a) (p a)
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"drop" []
gProperty :: Element e
=> Key e v
-> Greskell v
-> Walk SideEffect e e
gProperty :: forall e v.
Element e =>
Key e v -> Greskell v -> Walk SideEffect e e
gProperty Key e v
key Greskell v
val = Text -> [Text] -> Walk SideEffect e e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"property" [Key e v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Key e v
key, Greskell v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell v
val]
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
gPropertyV :: forall e (vp :: * -> *) v.
(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
gPropertyV Maybe (Greskell Cardinality)
mcard Key e v
key Greskell v
val [KeyValue (vp v)]
metaprops = Text -> [Text] -> Walk SideEffect e e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"property" ([Text]
arg_card [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
arg_keyval [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
arg_metaprops)
where
arg_card :: [Text]
arg_card = [Text]
-> (Greskell Cardinality -> [Text])
-> Maybe (Greskell Cardinality)
-> [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Greskell Cardinality
card -> [Greskell Cardinality -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Cardinality
card]) Maybe (Greskell Cardinality)
mcard
arg_keyval :: [Text]
arg_keyval = [Key e v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Key e v
key, Greskell v -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell v
val]
arg_metaprops :: [Text]
arg_metaprops = KeyValue (vp v) -> [Text]
forall {a}. KeyValue a -> [Text]
expand (KeyValue (vp v) -> [Text]) -> [KeyValue (vp v)] -> [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [KeyValue (vp v)]
metaprops
where
expand :: KeyValue a -> [Text]
expand (KeyValue Key a b
meta_key Greskell b
meta_val) = [Key a b -> Text
forall a. ToGreskell a => a -> Text
toGremlin Key a b
meta_key, Greskell b -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell b
meta_val]
expand (KeyNoValue Key a b
_) = []
data AddAnchor s e
= AddAnchor Text (GTraversal Transform s e)
anchorStep :: WalkType c => AddAnchor s e -> Walk c edge edge
anchorStep :: forall c s e edge. WalkType c => AddAnchor s e -> Walk c edge edge
anchorStep (AddAnchor Text
step_name GTraversal Transform s e
subtraversal) = Text -> [Text] -> Walk c edge edge
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
step_name [GTraversal Transform s e -> Text
forall a. ToGreskell a => a -> Text
toGremlin GTraversal Transform s e
subtraversal]
gFrom :: (ToGTraversal g) => g Transform s e -> AddAnchor s e
gFrom :: forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
gFrom = Text -> GTraversal Transform s e -> AddAnchor s e
forall s e. Text -> GTraversal Transform s e -> AddAnchor s e
AddAnchor Text
"from" (GTraversal Transform s e -> AddAnchor s e)
-> (g Transform s e -> GTraversal Transform s e)
-> g Transform s e
-> AddAnchor s e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g Transform s e -> GTraversal Transform s e
forall c s e. WalkType c => g c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal
gTo :: (ToGTraversal g) => g Transform s e -> AddAnchor s e
gTo :: forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
gTo = Text -> GTraversal Transform s e -> AddAnchor s e
forall s e. Text -> GTraversal Transform s e -> AddAnchor s e
AddAnchor Text
"to" (GTraversal Transform s e -> AddAnchor s e)
-> (g Transform s e -> GTraversal Transform s e)
-> g Transform s e
-> AddAnchor s e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g Transform s e -> GTraversal Transform s e
forall c s e. WalkType c => g c s e -> GTraversal c s e
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal
gAddE :: (Vertex vs, Vertex ve, Edge e)
=> Greskell Text
-> AddAnchor vs ve
-> Walk SideEffect vs e
gAddE :: forall vs ve e.
(Vertex vs, Vertex ve, Edge e) =>
Greskell Text -> AddAnchor vs ve -> Walk SideEffect vs e
gAddE Greskell Text
label AddAnchor vs ve
anch = (Text -> [Text] -> Walk SideEffect vs e
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"addE" [Greskell Text -> Text
forall a. ToGreskell a => a -> Text
toGremlin Greskell Text
label]) Walk SideEffect vs e -> Walk SideEffect e e -> Walk SideEffect vs e
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> AddAnchor vs ve -> Walk SideEffect e e
forall c s e edge. WalkType c => AddAnchor s e -> Walk c edge edge
anchorStep AddAnchor vs ve
anch
gAddE' :: Greskell Text -> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge
gAddE' :: Greskell Text
-> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge
gAddE' = Greskell Text
-> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge
forall vs ve e.
(Vertex vs, Vertex ve, Edge e) =>
Greskell Text -> AddAnchor vs ve -> Walk SideEffect vs e
gAddE
examples :: [(Text, Text)]
examples :: [(Text, Text)]
examples =
[ ( Greskell GraphTraversalSource -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Greskell GraphTraversalSource -> Text)
-> Greskell GraphTraversalSource -> Text
forall a b. (a -> b) -> a -> b
$ Text -> Greskell GraphTraversalSource
source Text
"g"
, Text
"g"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' ((Int -> Greskell (ElementID AVertex))
-> [Int] -> [Greskell (ElementID AVertex)]
forall a b. (a -> b) -> [a] -> [b]
map ((GValue -> ElementID AVertex)
-> Greskell GValue -> Greskell (ElementID AVertex)
forall a b. (a -> b) -> Greskell a -> Greskell b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GValue -> ElementID AVertex
forall e. GValue -> ElementID e
ElementID (Greskell GValue -> Greskell (ElementID AVertex))
-> (Int -> Greskell GValue) -> Int -> Greskell (ElementID AVertex)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Greskell GValue
forall a. Integral a => a -> Greskell GValue
gvalueInt) ([Int
1,Int
2,Int
3] :: [Int])))
, Text
"g.V(1,2,3)"
)
, ( GTraversal Transform () AEdge -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource -> GTraversal Transform () AEdge)
-> GTraversal Transform () AEdge
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
sE' ((Int -> Greskell (ElementID AEdge))
-> [Int] -> [Greskell (ElementID AEdge)]
forall a b. (a -> b) -> [a] -> [b]
map ((GValue -> ElementID AEdge)
-> Greskell GValue -> Greskell (ElementID AEdge)
forall a b. (a -> b) -> Greskell a -> Greskell b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GValue -> ElementID AEdge
forall e. GValue -> ElementID e
ElementID (Greskell GValue -> Greskell (ElementID AEdge))
-> (Int -> Greskell GValue) -> Int -> Greskell (ElementID AEdge)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Greskell GValue
forall a. Integral a => a -> Greskell GValue
gvalueInt) ([Int
1] :: [Int])))
, Text
"g.E(1)"
)
, ( GTraversal SideEffect () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& Greskell Text
-> Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex
sAddV' Greskell Text
"person")
, Text
"g.addV(\"person\")"
)
, ( GTraversal Any Any Any -> Text
forall a. ToGreskell a => a -> Text
toGremlin (GTraversal Any Any Any -> Text) -> GTraversal Any Any Any -> Text
forall a b. (a -> b) -> a -> b
$ Text -> GTraversal Any Any Any
forall c s e. Text -> GTraversal c s e
unsafeGTraversal Text
"g.V().count()"
, Text
"g.V().count()"
)
, ( GTraversal Transform () Any -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Any -> GTraversal Transform () Any
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Any] -> Walk Transform AVertex Any
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Any
"age"])
, Text
"g.V().values(\"age\")"
)
, ( GTraversal Transform () Any -> Text
forall a. ToGreskell a => a -> Text
toGremlin ([Key AVertex Any] -> Walk Transform AVertex Any
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Any
"age"] Walk Transform AVertex Any
-> GTraversal Transform () AVertex -> GTraversal Transform () Any
forall c b d a. Walk c b d -> GTraversal c a b -> GTraversal c a d
$. [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] (Greskell GraphTraversalSource -> GTraversal Transform () AVertex)
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
forall a b. (a -> b) -> a -> b
$ Text -> Greskell GraphTraversalSource
source Text
"g")
, Text
"g.V().values(\"age\")"
)
, ( GTraversal SideEffect () () -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& Greskell Text
-> Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex
sAddV' Greskell Text
"person" GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AVertex
-> GTraversal SideEffect () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Text
-> Greskell Text -> Walk SideEffect AVertex AVertex
forall e v.
Element e =>
Key e v -> Greskell v -> Walk SideEffect e e
gProperty Key AVertex Text
"name" (Greskell Text
"marko" :: Greskell Text) GTraversal SideEffect () AVertex
-> (GTraversal SideEffect () AVertex
-> GTraversal SideEffect () ())
-> GTraversal SideEffect () ()
forall a b. a -> (a -> b) -> b
& GTraversal SideEffect () AVertex -> GTraversal SideEffect () ()
forall c s e. WalkType c => GTraversal c s e -> GTraversal c s ()
gIterate)
, Text
"g.addV(\"person\").property(\"name\",\"marko\").iterate()"
)
, ( GTraversal Transform () Any -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Any -> GTraversal Transform () Any
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Text -> [Text] -> Walk Transform AVertex Any
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"valueMap" [Text
"'foo'", Text
"'bar'"])
, Text
"g.V().valueMap('foo','bar')"
)
, ( GTraversal Transform () Any -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Any -> GTraversal Transform () Any
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Transform AVertex Any
-> [Walk Transform Any Any] -> Walk Transform AVertex Any
forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (Text -> [Text] -> Walk Transform AVertex Any
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"path" []) [Text -> [Text] -> Walk Transform Any Any
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [Text
"'name'"], Text -> [Text] -> Walk Transform Any Any
forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [Text
"'age'"]])
, Text
"g.V().path().by('name').by('age')"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gFilter ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"]))
, Text
"g.V().filter(__.out(\"knows\"))"
)
, ( let la :: AsLabel AVertex
la = AsLabel AVertex
"a" :: AsLabel AVertex
age :: Key AVertex Int
age = Key AVertex Int
"age" :: Key AVertex Int
in GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex -> Walk Transform AVertex AVertex
forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
la GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell (LabeledP AVertex)
-> Maybe (ByProjection AVertex Int)
-> Walk Transform AVertex AVertex
forall c a b.
WalkType c =>
Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c a a
gWhereP1 (PParameter (LabeledP AVertex) -> Greskell (LabeledP AVertex)
forall p. PLike p => PParameter p -> Greskell p
pEq PParameter (LabeledP AVertex)
AsLabel AVertex
la) (ByProjection AVertex Int -> Maybe (ByProjection AVertex Int)
forall a. a -> Maybe a
Just (ByProjection AVertex Int -> Maybe (ByProjection AVertex Int))
-> ByProjection AVertex Int -> Maybe (ByProjection AVertex Int)
forall a b. (a -> b) -> a -> b
$ Key AVertex Int
-> ByProjection
(ProjectionLikeStart (Key AVertex Int))
(ProjectionLikeEnd (Key AVertex Int))
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy Key AVertex Int
age))
, Text
"g.V().as(\"a\").out().where(P.eq(\"a\")).by(\"age\")"
)
, ( let la :: AsLabel AVertex
la = AsLabel AVertex
"a" :: AsLabel AVertex
lb :: AsLabel AVertex
lb = AsLabel AVertex
"b" :: AsLabel AVertex
age :: Key AVertex Int
age = Key AVertex Int
"age" :: Key AVertex Int
in GTraversal Transform () Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex -> Walk Transform AVertex AVertex
forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
la GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex -> Walk Transform AVertex AVertex
forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
lb GTraversal Transform () AVertex
-> Walk Transform AVertex Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Int] -> Walk Transform AVertex Int
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
age] GTraversal Transform () Int
-> Walk Transform Int Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex
-> Greskell (LabeledP AVertex)
-> Maybe (ByProjection AVertex Any)
-> Walk Transform Int Int
forall c a b x.
WalkType c =>
AsLabel a
-> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c x x
gWhereP2 AsLabel AVertex
la (PParameter (LabeledP AVertex) -> Greskell (LabeledP AVertex)
forall p. PLike p => PParameter p -> Greskell p
pEq PParameter (LabeledP AVertex)
AsLabel AVertex
lb) Maybe (ByProjection AVertex Any)
forall a. Maybe a
Nothing)
, Text
"g.V().as(\"a\").out().as(\"b\").values(\"age\").where(\"a\",P.eq(\"b\"))"
)
, ( let label_a :: AsLabel AVertex
label_a = AsLabel AVertex
"a" :: AsLabel AVertex
label_b :: AsLabel AVertex
label_b = AsLabel AVertex
"b"
key_age :: Key AVertex Int
key_age = Key AVertex Int
"age" :: Key AVertex Int
patterns :: Logic MatchPattern
patterns =
Logic MatchPattern -> [Logic MatchPattern] -> Logic MatchPattern
forall a. Logic a -> [Logic a] -> Logic a
Logic.And
( AsLabel AVertex
-> Walk Transform AVertex AVertex -> Logic MatchPattern
forall c a b.
(WalkType c, Lift c Transform) =>
AsLabel a -> Walk c a b -> Logic MatchPattern
mPattern AsLabel AVertex
label_a ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> AsLabel AVertex -> Walk Transform AVertex AVertex
forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
label_b) )
[ AsLabel AVertex
-> Walk Filter AVertex AVertex -> Logic MatchPattern
forall c a b.
(WalkType c, Lift c Transform) =>
AsLabel a -> Walk c a b -> Logic MatchPattern
mPattern AsLabel AVertex
label_b (Key AVertex Int -> Greskell Int -> Walk Filter AVertex AVertex
forall s v. Element s => Key s v -> Greskell v -> Walk Filter s s
gHas2' Key AVertex Int
key_age Greskell Int
25) ]
in GTraversal Transform () (SelectedMap GValue) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex MatchResult
-> GTraversal Transform () MatchResult
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Logic MatchPattern -> Walk Transform AVertex MatchResult
forall a. Logic MatchPattern -> Walk Transform a MatchResult
gMatch Logic MatchPattern
patterns GTraversal Transform () MatchResult
-> Walk Transform MatchResult (SelectedMap GValue)
-> GTraversal Transform () (SelectedMap GValue)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex
-> AsLabel AVertex
-> [AsLabel Any]
-> Walk Transform MatchResult (SelectedMap GValue)
forall a b c s.
AsLabel a
-> AsLabel b
-> [AsLabel c]
-> Walk Transform s (SelectedMap GValue)
gSelectN AsLabel AVertex
label_a AsLabel AVertex
label_b [])
, Text
"g.V().match(__.as(\"a\").out().as(\"b\"),__.as(\"b\").has(\"age\",25)).select(\"a\",\"b\")"
)
, ( GTraversal Transform () Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Int] -> Walk Transform AVertex Int
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
"age" :: Key AVertex Int] GTraversal Transform () Int
-> Walk Transform Int Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Int -> Walk Transform Int Int
forall c v. WalkType c => Greskell v -> Walk c v v
gIs Greskell Int
30)
, Text
"g.V().values(\"age\").is(30)"
)
, ( GTraversal Transform () Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Int] -> Walk Transform AVertex Int
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
"age" :: Key AVertex Int] GTraversal Transform () Int
-> Walk Transform Int Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell (P Int) -> Walk Transform Int Int
forall c v. WalkType c => Greskell (P v) -> Walk c v v
gIsP (PParameter (P Int) -> Greskell (P Int)
forall p. PLike p => PParameter p -> Greskell p
pLte Greskell Int
PParameter (P Int)
30))
, Text
"g.V().values(\"age\").is(P.lte(30))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Any -> Walk Transform AVertex AVertex
forall c s v. (WalkType c, Element s) => Key s v -> Walk c s s
gHas1 Key AVertex Any
"age")
, Text
"g.V().has(\"age\")"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Int -> Greskell Int -> Walk Transform AVertex AVertex
forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell v -> Walk c s s
gHas2 Key AVertex Int
"age" (Greskell Int
31 :: Greskell Int))
, Text
"g.V().has(\"age\",31)"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Int
-> Greskell (P Int) -> Walk Transform AVertex AVertex
forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell (P v) -> Walk c s s
gHas2P Key AVertex Int
"age" (PParameter (P Int) -> PParameter (P Int) -> Greskell (P Int)
forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pBetween (Greskell Int
30 :: Greskell Int) Greskell Int
PParameter (P Int)
40))
, Text
"g.V().has(\"age\",P.between(30,40))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Text -> Walk Transform AVertex AVertex
forall s c. (Element s, WalkType c) => Greskell Text -> Walk c s s
gHasLabel Greskell Text
"person")
, Text
"g.V().hasLabel(\"person\")"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell (P Text) -> Walk Transform AVertex AVertex
forall s c.
(Element s, WalkType c) =>
Greskell (P Text) -> Walk c s s
gHasLabelP (PParameter (P Text) -> Greskell (P Text)
forall p. PLike p => PParameter p -> Greskell p
pEq Greskell Text
PParameter (P Text)
"person"))
, Text
"g.V().hasLabel(P.eq(\"person\"))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell (ElementID AVertex) -> Walk Transform AVertex AVertex
forall s c.
(Element s, WalkType c) =>
Greskell (ElementID s) -> Walk c s s
gHasId ((GValue -> ElementID AVertex)
-> Greskell GValue -> Greskell (ElementID AVertex)
forall a b. (a -> b) -> Greskell a -> Greskell b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GValue -> ElementID AVertex
forall e. GValue -> ElementID e
ElementID (Greskell GValue -> Greskell (ElementID AVertex))
-> Greskell GValue -> Greskell (ElementID AVertex)
forall a b. (a -> b) -> a -> b
$ Int -> Greskell GValue
forall a. Integral a => a -> Greskell GValue
gvalueInt (Int -> Greskell GValue) -> Int -> Greskell GValue
forall a b. (a -> b) -> a -> b
$ (Int
7 :: Int)))
, Text
"g.V().hasId(7)"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell (P (ElementID AVertex)) -> Walk Transform AVertex AVertex
forall s c.
(Element s, WalkType c) =>
Greskell (P (ElementID s)) -> Walk c s s
gHasIdP (PParameter (P (ElementID AVertex))
-> Greskell (P (ElementID AVertex))
forall p. PLike p => PParameter p -> Greskell p
pLte (PParameter (P (ElementID AVertex))
-> Greskell (P (ElementID AVertex)))
-> PParameter (P (ElementID AVertex))
-> Greskell (P (ElementID AVertex))
forall a b. (a -> b) -> a -> b
$ (GValue -> ElementID AVertex)
-> Greskell GValue -> Greskell (ElementID AVertex)
forall a b. (a -> b) -> Greskell a -> Greskell b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GValue -> ElementID AVertex
forall e. GValue -> ElementID e
ElementID (Greskell GValue -> Greskell (ElementID AVertex))
-> Greskell GValue -> Greskell (ElementID AVertex)
forall a b. (a -> b) -> a -> b
$ Int -> Greskell GValue
forall a. Integral a => a -> Greskell GValue
gvalueInt (Int
100 :: Int)))
, Text
"g.V().hasId(P.lte(100))"
)
, ( GTraversal Transform () (AVertexProperty Any) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (AVertexProperty Any)
-> GTraversal Transform () (AVertexProperty Any)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Any] -> Walk Transform AVertex (AVertexProperty Any)
forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [] GTraversal Transform () (AVertexProperty Any)
-> Walk Transform (AVertexProperty Any) (AVertexProperty Any)
-> GTraversal Transform () (AVertexProperty Any)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Text
-> Walk Transform (AVertexProperty Any) (AVertexProperty Any)
forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell Text -> Walk c (p v) (p v)
gHasKey Greskell Text
"age")
, Text
"g.V().properties().hasKey(\"age\")"
)
, ( GTraversal Transform () (AVertexProperty Int) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (AVertexProperty Int)
-> GTraversal Transform () (AVertexProperty Int)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Int] -> Walk Transform AVertex (AVertexProperty Int)
forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [Key AVertex Int
"age"] GTraversal Transform () (AVertexProperty Int)
-> Walk Transform (AVertexProperty Int) (AVertexProperty Int)
-> GTraversal Transform () (AVertexProperty Int)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Int
-> Walk Transform (AVertexProperty Int) (AVertexProperty Int)
forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell v -> Walk c (p v) (p v)
gHasValue (Greskell Int
32 :: Greskell Int))
, Text
"g.V().properties(\"age\").hasValue(32)"
)
, ( GTraversal Transform () (AVertexProperty Int) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (AVertexProperty Int)
-> GTraversal Transform () (AVertexProperty Int)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Int] -> Walk Transform AVertex (AVertexProperty Int)
forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [Key AVertex Int
"age"] GTraversal Transform () (AVertexProperty Int)
-> Walk Transform (AVertexProperty Int) (AVertexProperty Int)
-> GTraversal Transform () (AVertexProperty Int)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell (P Int)
-> Walk Transform (AVertexProperty Int) (AVertexProperty Int)
forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell (P v) -> Walk c (p v) (p v)
gHasValueP (PParameter (P Int) -> PParameter (P Int) -> Greskell (P Int)
forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pBetween (Greskell Int
30 :: Greskell Int) Greskell Int
PParameter (P Int)
40))
, Text
"g.V().properties(\"age\").hasValue(P.between(30,40))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Walk Transform AVertex AVertex] -> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gAnd [[Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"], Key AVertex Any -> Walk Transform AVertex AVertex
forall c s v. (WalkType c, Element s) => Key s v -> Walk c s s
gHas1 Key AVertex Any
"age"])
, Text
"g.V().and(__.out(\"knows\"),__.has(\"age\"))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Walk Transform AVertex AVertex] -> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gOr [[Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"], Key AVertex Any -> Walk Transform AVertex AVertex
forall c s v. (WalkType c, Element s) => Key s v -> Walk c s s
gHas1 Key AVertex Any
"age"])
, Text
"g.V().or(__.out(\"knows\"),__.has(\"age\"))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gNot ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"]))
, Text
"g.V().not(__.out(\"knows\"))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Int -> Greskell Int -> Walk Transform AVertex AVertex
forall s. Greskell Int -> Greskell Int -> Walk Transform s s
gRange Greskell Int
0 Greskell Int
100)
, Text
"g.V().range(0,100)"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
forall a. Maybe a
Nothing (Greskell Int -> Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall c s. Greskell Int -> Maybe (RepeatPos, RepeatUntil c s)
gTimes Greskell Int
3) Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall a. Maybe a
Nothing ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().times(3).repeat(__.out())"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
forall a. Maybe a
Nothing (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
gUntilHead (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatUntil Transform AVertex))
-> Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall a b. (a -> b) -> a -> b
$ Greskell Text -> Walk Filter AVertex AVertex
forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall a. Maybe a
Nothing ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().until(__.hasLabel(\"person\")).repeat(__.out())"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
forall a. Maybe a
Nothing (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
gUntilTail (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatUntil Transform AVertex))
-> Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall a b. (a -> b) -> a -> b
$ Greskell Text -> Walk Filter AVertex AVertex
forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall a. Maybe a
Nothing ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().repeat(__.out()).until(__.hasLabel(\"person\"))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
forall a. Maybe a
Nothing Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall a. Maybe a
Nothing Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall c s. Maybe (RepeatPos, RepeatEmit c s)
gEmitHead ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().emit().repeat(__.out())"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
forall a. Maybe a
Nothing Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall a. Maybe a
Nothing Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall c s. Maybe (RepeatPos, RepeatEmit c s)
gEmitTail ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().repeat(__.out()).emit()"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
forall a. Maybe a
Nothing Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall a. Maybe a
Nothing (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
gEmitHeadT (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatEmit Transform AVertex))
-> Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall a b. (a -> b) -> a -> b
$ Greskell Text -> Walk Filter AVertex AVertex
forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().emit(__.hasLabel(\"person\")).repeat(__.out())"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
forall a. Maybe a
Nothing Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall a. Maybe a
Nothing (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
gEmitTailT (Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatEmit Transform AVertex))
-> Walk Filter AVertex AVertex
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall a b. (a -> b) -> a -> b
$ Greskell Text -> Walk Filter AVertex AVertex
forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().repeat(__.out()).emit(__.hasLabel(\"person\"))"
)
, ( let loop_label :: Maybe RepeatLabel
loop_label = RepeatLabel -> Maybe RepeatLabel
forall a. a -> Maybe a
Just RepeatLabel
"the_loop"
in GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
-> Maybe (RepeatPos, RepeatEmit Transform AVertex)
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s.
(ToGTraversal g, WalkType c) =>
Maybe RepeatLabel
-> Maybe (RepeatPos, RepeatUntil c s)
-> Maybe (RepeatPos, RepeatEmit c s)
-> g c s s
-> Walk c s s
gRepeat Maybe RepeatLabel
loop_label (Walk Transform AVertex Int
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall (g :: * -> * -> * -> *) c cc s e.
(ToGTraversal g, WalkType c, WalkType cc, Split cc c) =>
g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
gUntilTail (Walk Transform AVertex Int
-> Maybe (RepeatPos, RepeatUntil Transform AVertex))
-> Walk Transform AVertex Int
-> Maybe (RepeatPos, RepeatUntil Transform AVertex)
forall a b. (a -> b) -> a -> b
$ Maybe RepeatLabel -> Walk Transform AVertex Int
forall s. Maybe RepeatLabel -> Walk Transform s Int
gLoops Maybe RepeatLabel
loop_label Walk Transform AVertex Int
-> Walk Transform Int Int -> Walk Transform AVertex Int
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Greskell Int -> Walk Transform Int Int
forall c v. WalkType c => Greskell v -> Walk c v v
gIs Greskell Int
3) Maybe (RepeatPos, RepeatEmit Transform AVertex)
forall a. Maybe a
Nothing ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().repeat(\"the_loop\",__.out()).until(__.loops(\"the_loop\").is(3))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Walk c s e
gLocal ( [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Greskell Int -> Walk Transform AVertex AVertex
forall s. Greskell Int -> Walk Transform s s
gLimit Greskell Int
3 ))
, Text
"g.V().local(__.out().limit(3))"
)
, ( let key_age :: Key AVertex Int
key_age = Key AVertex Int
"age" :: Key AVertex Int
key_birth_year :: Key AVertex Int
key_birth_year = (Key AVertex Int
"birth_year" :: Key AVertex Int)
in GTraversal Transform () Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Walk Transform AVertex Int] -> Walk Transform AVertex Int
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
[g c s e] -> Walk c s e
gUnion [[Key AVertex Int] -> Walk Transform AVertex Int
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
key_age], [Key AVertex Int] -> Walk Transform AVertex Int
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
key_birth_year]])
, Text
"g.V().union(__.values(\"age\"),__.values(\"birth_year\"))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Walk Transform AVertex AVertex] -> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) cc c s e.
(ToGTraversal g, Split cc c, Lift Transform c, WalkType c,
WalkType cc) =>
[g cc s e] -> Walk c s e
gCoalesce [[Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [], [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gIn' []])
, Text
"g.V().coalesce(__.out(),__.in())"
)
, ( let key_age :: Key AVertex Int
key_age = Key AVertex Int
"age" :: Key AVertex Int
in GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Filter AVertex AVertex
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex
forall (g :: * -> * -> * -> *) cc c s ep e.
(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
gChoose3 (Key AVertex Int -> Greskell Int -> Walk Filter AVertex AVertex
forall s v. Element s => Key s v -> Greskell v -> Walk Filter s s
gHas2' Key AVertex Int
key_age Greskell Int
30) ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gIn' []) ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().choose(__.has(\"age\",30),__.in(),__.out())"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe (ByProjection AVertex Any) -> Walk Transform AVertex AVertex
forall s e. Maybe (ByProjection s e) -> Walk Transform s s
gDedup Maybe (ByProjection AVertex Any)
forall a. Maybe a
Nothing)
, Text
"g.V().dedup()"
)
, ( let key_age :: Key AVertex Int
key_age = Key AVertex Int
"age" :: Key AVertex Int
in GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe (ByProjection AVertex Int) -> Walk Transform AVertex AVertex
forall s e. Maybe (ByProjection s e) -> Walk Transform s s
gDedup (ByProjection AVertex Int -> Maybe (ByProjection AVertex Int)
forall a. a -> Maybe a
Just (ByProjection AVertex Int -> Maybe (ByProjection AVertex Int))
-> ByProjection AVertex Int -> Maybe (ByProjection AVertex Int)
forall a b. (a -> b) -> a -> b
$ Key AVertex Int
-> ByProjection
(ProjectionLikeStart (Key AVertex Int))
(ProjectionLikeEnd (Key AVertex Int))
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy Key AVertex Int
key_age))
, Text
"g.V().dedup().by(\"age\")"
)
, ( let label_a :: AsLabel AVertex
label_a = AsLabel AVertex
"a" :: AsLabel AVertex
label_b :: AsLabel AVertex
label_b = AsLabel AVertex
"b" :: AsLabel AVertex
in GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex -> Walk Transform AVertex AVertex
forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
label_a GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex -> Walk Transform AVertex AVertex
forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
label_b GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. AsLabel AVertex
-> [AsLabel AVertex]
-> Maybe (ByProjection AVertex Any)
-> Walk Transform AVertex AVertex
forall a e s.
AsLabel a
-> [AsLabel a] -> Maybe (ByProjection a e) -> Walk Transform s s
gDedupN AsLabel AVertex
label_a [AsLabel AVertex
label_b] Maybe (ByProjection AVertex Any)
forall a. Maybe a
Nothing)
, Text
"g.V().as(\"a\").out().as(\"b\").dedup(\"a\",\"b\")"
)
, ( let key_age :: Key AVertex Int
key_age = Key AVertex Int
"age" :: Key AVertex Int
in GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [ByComparator AVertex] -> Walk Transform AVertex AVertex
forall s. [ByComparator s] -> Walk Transform s s
gOrder [Key AVertex Int
-> ByComparator (ProjectionLikeStart (Key AVertex Int))
forall p.
(ProjectionLike p, ToGreskell p) =>
p -> ByComparator (ProjectionLikeStart p)
gBy1 Key AVertex Int
key_age])
, Text
"g.V().order().by(\"age\")"
)
, ( let key_age :: Key AVertex Int
key_age = Key AVertex Int
"age" :: Key AVertex Int
in GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [ByComparator AVertex] -> Walk Transform AVertex AVertex
forall s. [ByComparator s] -> Walk Transform s s
gOrder [Key AVertex Int
-> Greskell (Order Int)
-> ByComparator (ProjectionLikeStart (Key AVertex Int))
forall p comp.
(ProjectionLike p, ToGreskell p, Comparator comp,
ProjectionLikeEnd p ~ CompareArg comp) =>
p -> Greskell comp -> ByComparator (ProjectionLikeStart p)
gBy2 Key AVertex Int
key_age Greskell (Order Int)
forall a. Greskell (Order a)
oDecr, Greskell (T AVertex (ElementID AVertex))
-> ByComparator
(ProjectionLikeStart (Greskell (T AVertex (ElementID AVertex))))
forall p.
(ProjectionLike p, ToGreskell p) =>
p -> ByComparator (ProjectionLikeStart p)
gBy1 Greskell (T AVertex (ElementID AVertex))
forall a. Element a => Greskell (T a (ElementID a))
tId])
, Text
"g.V().order().by(\"age\",Order.decr).by(T.id)"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [ByComparator AVertex] -> Walk Transform AVertex AVertex
forall s. [ByComparator s] -> Walk Transform s s
gOrder [Walk Transform AVertex Int
-> Greskell (Order Int)
-> ByComparator (ProjectionLikeStart (Walk Transform AVertex Int))
forall p comp.
(ProjectionLike p, ToGreskell p, Comparator comp,
ProjectionLikeEnd p ~ CompareArg comp) =>
p -> Greskell comp -> ByComparator (ProjectionLikeStart p)
gBy2 ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"] Walk Transform AVertex AVertex
-> Walk Transform AVertex Int -> Walk Transform AVertex Int
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Walk Transform AVertex Int
forall a. Walk Transform a Int
gCount) Greskell (Order Int)
forall a. Greskell (Order a)
oIncr, Greskell (T AVertex (ElementID AVertex))
-> Greskell (Order (ElementID AVertex))
-> ByComparator
(ProjectionLikeStart (Greskell (T AVertex (ElementID AVertex))))
forall p comp.
(ProjectionLike p, ToGreskell p, Comparator comp,
ProjectionLikeEnd p ~ CompareArg comp) =>
p -> Greskell comp -> ByComparator (ProjectionLikeStart p)
gBy2 Greskell (T AVertex (ElementID AVertex))
forall a. Element a => Greskell (T a (ElementID a))
tId Greskell (Order (ElementID AVertex))
forall a. Greskell (Order a)
oIncr])
, Text
"g.V().order().by(__.out(\"knows\").count(),Order.incr).by(T.id,Order.incr)"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [ByComparator AVertex] -> Walk Transform AVertex AVertex
forall s. [ByComparator s] -> Walk Transform s s
gOrder [ByComparator AVertex
"age"])
, Text
"g.V().order().by(\"age\")"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall c cc (g :: * -> * -> * -> *) s e.
(Lift Transform c, Split cc c, ToGTraversal g, WalkType c,
WalkType cc) =>
g cc s e -> Walk c s e
gFlatMap ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"] Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"created"]))
, Text
"g.V().flatMap(__.out(\"knows\").out(\"created\"))"
)
, ( GTraversal Transform () Int -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Int -> GTraversal Transform () Int
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Int -> Walk Transform AVertex Int
forall a s. Greskell a -> Walk Transform s a
gConstant (Greskell Int
10 :: Greskell Int))
, Text
"g.V().constant(10)"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex [AVertex]
-> GTraversal Transform () [AVertex]
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Transform AVertex [AVertex]
forall a. Walk Transform a [a]
gFold GTraversal Transform () [AVertex]
-> Walk Transform [AVertex] AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk Transform [AVertex] (IteratorItem [AVertex])
Walk Transform [AVertex] AVertex
forall a. AsIterator a => Walk Transform a (IteratorItem a)
gUnfold)
, Text
"g.V().fold().unfold()"
)
, ( GTraversal Transform () Any -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex Any -> GTraversal Transform () Any
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Any] -> Walk Transform AVertex Any
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Any
"name", Key AVertex Any
"age"])
, Text
"g.V().values(\"name\",\"age\")"
)
, ( GTraversal Transform () (AVertexProperty Any) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (AVertexProperty Any)
-> GTraversal Transform () (AVertexProperty Any)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AVertex Any] -> Walk Transform AVertex (AVertexProperty Any)
forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [Key AVertex Any
"age"])
, Text
"g.V().properties(\"age\")"
)
, ( GTraversal Transform () (PMap Multi GValue) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (PMap Multi GValue)
-> GTraversal Transform () (PMap Multi GValue)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Keys AVertex
-> Walk
Transform AVertex (PMap (ElementPropertyContainer AVertex) GValue)
forall s.
Element s =>
Keys s
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
gValueMap Keys AVertex
forall a. Keys a
KeysNil)
, Text
"g.V().valueMap()"
)
, ( GTraversal Transform () (PMap Multi GValue) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (PMap Multi GValue)
-> GTraversal Transform () (PMap Multi GValue)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Keys AVertex
-> Walk
Transform AVertex (PMap (ElementPropertyContainer AVertex) GValue)
forall s.
Element s =>
Keys s
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
gValueMap (Key AVertex Any
"name" Key AVertex Any -> Keys AVertex -> Keys AVertex
forall a b. Key a b -> Keys a -> Keys a
-: Key AVertex Any
"age" Key AVertex Any -> Keys AVertex -> Keys AVertex
forall a b. Key a b -> Keys a -> Keys a
-: Keys AVertex
forall a. Keys a
KeysNil))
, Text
"g.V().valueMap(\"name\",\"age\")"
)
, ( GTraversal Transform () (SelectedMap GValue) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (SelectedMap GValue)
-> GTraversal Transform () (SelectedMap GValue)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Keys AVertex -> Walk Transform AVertex (SelectedMap GValue)
forall s.
Element s =>
Keys s -> Walk Transform s (SelectedMap GValue)
gElementMap Keys AVertex
forall a. Keys a
KeysNil)
, Text
"g.V().elementMap()"
)
, ( GTraversal Transform () (SelectedMap GValue) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (SelectedMap GValue)
-> GTraversal Transform () (SelectedMap GValue)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Keys AVertex -> Walk Transform AVertex (SelectedMap GValue)
forall s.
Element s =>
Keys s -> Walk Transform s (SelectedMap GValue)
gElementMap (Key AVertex Any
"name" Key AVertex Any -> Keys AVertex -> Keys AVertex
forall a b. Key a b -> Keys a -> Keys a
-: Key AVertex Any
"age" Key AVertex Any -> Keys AVertex -> Keys AVertex
forall a b. Key a b -> Keys a -> Keys a
-: Keys AVertex
forall a. Keys a
KeysNil))
, Text
"g.V().elementMap(\"name\",\"age\")"
)
, ( let name_label :: AsLabel Text
name_label = AsLabel Text
"a" :: AsLabel Text
name_key :: Key AVertex Text
name_key = Key AVertex Text
"name" :: Key AVertex Text
count_label :: AsLabel Int
count_label = AsLabel Int
"b" :: AsLabel Int
in GTraversal Transform () (SelectedMap GValue) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (SelectedMap GValue)
-> GTraversal Transform () (SelectedMap GValue)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. LabeledByProjection AVertex
-> [LabeledByProjection AVertex]
-> Walk Transform AVertex (SelectedMap GValue)
forall s.
LabeledByProjection s
-> [LabeledByProjection s] -> Walk Transform s (SelectedMap GValue)
gProject (AsLabel (ProjectionLikeEnd (Key AVertex Text))
-> Key AVertex Text
-> LabeledByProjection (ProjectionLikeStart (Key AVertex Text))
forall p.
(ProjectionLike p, ToGreskell p) =>
AsLabel (ProjectionLikeEnd p)
-> p -> LabeledByProjection (ProjectionLikeStart p)
gByL AsLabel Text
AsLabel (ProjectionLikeEnd (Key AVertex Text))
name_label Key AVertex Text
name_key) [AsLabel (ProjectionLikeEnd (Walk Transform AVertex Int))
-> Walk Transform AVertex Int
-> LabeledByProjection
(ProjectionLikeStart (Walk Transform AVertex Int))
forall p.
(ProjectionLike p, ToGreskell p) =>
AsLabel (ProjectionLikeEnd p)
-> p -> LabeledByProjection (ProjectionLikeStart p)
gByL AsLabel Int
AsLabel (ProjectionLikeEnd (Walk Transform AVertex Int))
count_label ([Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] Walk Transform AVertex AVertex
-> Walk Transform AVertex Int -> Walk Transform AVertex Int
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Walk Transform AVertex Int
forall a. Walk Transform a Int
gCount), AsLabel
(ProjectionLikeEnd (Greskell (T AVertex (ElementID AVertex))))
-> Greskell (T AVertex (ElementID AVertex))
-> LabeledByProjection
(ProjectionLikeStart (Greskell (T AVertex (ElementID AVertex))))
forall p.
(ProjectionLike p, ToGreskell p) =>
AsLabel (ProjectionLikeEnd p)
-> p -> LabeledByProjection (ProjectionLikeStart p)
gByL AsLabel (ElementID AVertex)
AsLabel
(ProjectionLikeEnd (Greskell (T AVertex (ElementID AVertex))))
"c" Greskell (T AVertex (ElementID AVertex))
forall a. Element a => Greskell (T a (ElementID a))
tId])
, Text
"g.V().project(\"a\",\"b\",\"c\").by(\"name\").by(__.out().count()).by(T.id)"
)
, ( let inE :: Walk Transform AVertex AEdge
inE = [Greskell Text] -> Walk Transform AVertex AEdge
forall v. Vertex v => [Greskell Text] -> Walk Transform v AEdge
gInE' [] :: Walk Transform AVertex AEdge
in GTraversal Transform () (Path Any) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] GTraversal Transform () AVertex
-> Walk Transform AVertex (Path Any)
-> GTraversal Transform () (Path Any)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. ByProjection AVertex Any
-> [ByProjection AVertex Any] -> Walk Transform AVertex (Path Any)
forall a b s.
ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b)
gPathBy ByProjection AVertex Any
"name" [Walk Transform AVertex Any
-> ByProjection
(ProjectionLikeStart (Walk Transform AVertex Any))
(ProjectionLikeEnd (Walk Transform AVertex Any))
forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy (Walk Transform AVertex Any
-> ByProjection
(ProjectionLikeStart (Walk Transform AVertex Any))
(ProjectionLikeEnd (Walk Transform AVertex Any)))
-> Walk Transform AVertex Any
-> ByProjection
(ProjectionLikeStart (Walk Transform AVertex Any))
(ProjectionLikeEnd (Walk Transform AVertex Any))
forall a b. (a -> b) -> a -> b
$ Walk Transform AVertex AEdge
inE Walk Transform AVertex AEdge
-> Walk Transform AEdge Any -> Walk Transform AVertex Any
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> [Key AEdge Any] -> Walk Transform AEdge Any
forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AEdge Any
"relation"]])
, Text
"g.V().out().path().by(\"name\").by(__.inE().values(\"relation\"))"
)
, ( GTraversal Transform () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [(GValue -> ElementID AVertex)
-> Greskell GValue -> Greskell (ElementID AVertex)
forall a b. (a -> b) -> Greskell a -> Greskell b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GValue -> ElementID AVertex
forall e. GValue -> ElementID e
ElementID (Greskell GValue -> Greskell (ElementID AVertex))
-> Greskell GValue -> Greskell (ElementID AVertex)
forall a b. (a -> b) -> a -> b
$ Int -> Greskell GValue
forall a. Integral a => a -> Greskell GValue
gvalueInt (Int
8 :: Int)] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Greskell Text] -> Walk Transform AVertex AVertex
forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"])
, Text
"g.V(8).out(\"knows\")"
)
, ( GTraversal SideEffect () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> (GTraversal Transform () AVertex
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& GTraversal Transform () AVertex -> GTraversal SideEffect () AVertex
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AVertex
-> GTraversal SideEffect () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Text
-> Greskell Text -> Walk SideEffect AVertex AVertex
forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell v -> Walk c s s
gHas2 Key AVertex Text
"name" (Greskell Text
"marko" :: Greskell Text) GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AVertex
-> GTraversal SideEffect () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk SideEffect AVertex AVertex -> Walk SideEffect AVertex AVertex
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c, Split c SideEffect) =>
g c s e -> Walk SideEffect s s
gSideEffect' (Greskell Text -> Walk SideEffect AVertex AVertex
forall a. Greskell Text -> Walk SideEffect a AVertex
gAddV' Greskell Text
"toshio"))
, Text
"g.V().has(\"name\",\"marko\").sideEffect(__.addV(\"toshio\"))"
)
, ( GTraversal SideEffect () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Text -> Greskell Text -> Walk Transform AVertex AVertex
forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell v -> Walk c s s
gHas2 Key AVertex Text
"name" (Greskell Text
"marko" :: Greskell Text) GTraversal Transform () AVertex
-> (GTraversal Transform () AVertex
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& GTraversal Transform () AVertex -> GTraversal SideEffect () AVertex
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AVertex
-> GTraversal SideEffect () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk SideEffect AVertex AVertex
forall e. Element e => Walk SideEffect e e
gDrop)
, Text
"g.V().has(\"name\",\"marko\").drop()"
)
, ( GTraversal SideEffect () (AProperty Any) -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource -> GTraversal Transform () AEdge)
-> GTraversal Transform () AEdge
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
sE' [] GTraversal Transform () AEdge
-> Walk Transform AEdge (AProperty Any)
-> GTraversal Transform () (AProperty Any)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. [Key AEdge Any] -> Walk Transform AEdge (AProperty Any)
forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [Key AEdge Any
"weight"] GTraversal Transform () (AProperty Any)
-> (GTraversal Transform () (AProperty Any)
-> GTraversal SideEffect () (AProperty Any))
-> GTraversal SideEffect () (AProperty Any)
forall a b. a -> (a -> b) -> b
& GTraversal Transform () (AProperty Any)
-> GTraversal SideEffect () (AProperty Any)
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk GTraversal SideEffect () (AProperty Any)
-> Walk SideEffect (AProperty Any) (AProperty Any)
-> GTraversal SideEffect () (AProperty Any)
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Walk SideEffect (AProperty Any) (AProperty Any)
forall (p :: * -> *) a. Property p => Walk SideEffect (p a) (p a)
gDropP)
, Text
"g.E().properties(\"weight\").drop()"
)
, ( GTraversal SideEffect () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> (GTraversal Transform () AVertex
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& GTraversal Transform () AVertex -> GTraversal SideEffect () AVertex
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AVertex
-> GTraversal SideEffect () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Int -> Greskell Int -> Walk SideEffect AVertex AVertex
forall e v.
Element e =>
Key e v -> Greskell v -> Walk SideEffect e e
gProperty Key AVertex Int
"age" (Greskell Int
20 :: Greskell Int))
, Text
"g.V().property(\"age\",20)"
)
, ( let key_location :: Key AVertex Text
key_location = Key AVertex Text
"location" :: Key AVertex Text
key_since :: Key (AVertexProperty Text) Text
key_since = Key (AVertexProperty Text) Text
"since" :: Key (AVertexProperty Text) Text
key_score :: Key (AVertexProperty Text) Int
key_score = Key (AVertexProperty Text) Int
"score" :: Key (AVertexProperty Text) Int
in GTraversal SideEffect () AVertex -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> (GTraversal Transform () AVertex
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& GTraversal Transform () AVertex -> GTraversal SideEffect () AVertex
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AVertex
-> GTraversal SideEffect () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Maybe (Greskell Cardinality)
-> Key AVertex Text
-> Greskell Text
-> [KeyValue (AVertexProperty Text)]
-> Walk SideEffect AVertex AVertex
forall e (vp :: * -> *) v.
(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
gPropertyV (Greskell Cardinality -> Maybe (Greskell Cardinality)
forall a. a -> Maybe a
Just Greskell Cardinality
cList) Key AVertex Text
key_location Greskell Text
"New York" [Key (AVertexProperty Text) Text
key_since Key (AVertexProperty Text) Text
-> Greskell Text -> KeyValue (AVertexProperty Text)
forall a b. Key a b -> Greskell b -> KeyValue a
=: Greskell Text
"2012-09-23", Key (AVertexProperty Text) Int
key_score Key (AVertexProperty Text) Int
-> Greskell Int -> KeyValue (AVertexProperty Text)
forall a b. Key a b -> Greskell b -> KeyValue a
=: Greskell Int
8])
, Text
"g.V().property(list,\"location\",\"New York\",\"since\",\"2012-09-23\",\"score\",8)"
)
, ( let key_name :: Key AVertex Text
key_name = Key AVertex Text
"name" :: Key AVertex Text
in GTraversal SideEffect () AEdge -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> (GTraversal Transform () AVertex
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& GTraversal Transform () AVertex -> GTraversal SideEffect () AVertex
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AEdge -> GTraversal SideEffect () AEdge
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Text
-> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge
gAddE' Greskell Text
"knows" (Walk Transform AVertex AVertex -> AddAnchor AVertex AVertex
forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
gFrom (Walk Transform AVertex AVertex -> AddAnchor AVertex AVertex)
-> Walk Transform AVertex AVertex -> AddAnchor AVertex AVertex
forall a b. (a -> b) -> a -> b
$ [Greskell (ElementID AVertex)] -> Walk Transform AVertex AVertex
forall s.
[Greskell (ElementID AVertex)] -> Walk Transform s AVertex
gV' [] Walk Transform AVertex AVertex
-> Walk Transform AVertex AVertex -> Walk Transform AVertex AVertex
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Key AVertex Text -> Greskell Text -> Walk Transform AVertex AVertex
forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell v -> Walk c s s
gHas2 Key AVertex Text
key_name Greskell Text
"marko"))
, Text
"g.V().addE(\"knows\").from(__.V().has(\"name\",\"marko\"))"
)
, ( let key_name :: Key AVertex Text
key_name = Key AVertex Text
"name" :: Key AVertex Text
in GTraversal SideEffect () AEdge -> Text
forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" Greskell GraphTraversalSource
-> (Greskell GraphTraversalSource
-> GTraversal Transform () AVertex)
-> GTraversal Transform () AVertex
forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] GTraversal Transform () AVertex
-> Walk Transform AVertex AVertex
-> GTraversal Transform () AVertex
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Key AVertex Text -> Greskell Text -> Walk Transform AVertex AVertex
forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell v -> Walk c s s
gHas2 Key AVertex Text
key_name Greskell Text
"marko" GTraversal Transform () AVertex
-> (GTraversal Transform () AVertex
-> GTraversal SideEffect () AVertex)
-> GTraversal SideEffect () AVertex
forall a b. a -> (a -> b) -> b
& GTraversal Transform () AVertex -> GTraversal SideEffect () AVertex
forall from to s e.
(WalkType from, WalkType to, Lift from to) =>
GTraversal from s e -> GTraversal to s e
forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk GTraversal SideEffect () AVertex
-> Walk SideEffect AVertex AEdge -> GTraversal SideEffect () AEdge
forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. Greskell Text
-> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge
gAddE' Greskell Text
"knows" (Walk Transform AVertex AVertex -> AddAnchor AVertex AVertex
forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
gTo (Walk Transform AVertex AVertex -> AddAnchor AVertex AVertex)
-> Walk Transform AVertex AVertex -> AddAnchor AVertex AVertex
forall a b. (a -> b) -> a -> b
$ [Greskell (ElementID AVertex)] -> Walk Transform AVertex AVertex
forall s.
[Greskell (ElementID AVertex)] -> Walk Transform s AVertex
gV' []))
, Text
"g.V().has(\"name\",\"marko\").addE(\"knows\").to(__.V())"
)
]