{-# 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
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
showList :: [GTraversal c s e] -> ShowS
$cshowList :: forall c s e. [GTraversal c s e] -> ShowS
show :: GTraversal c s e -> String
$cshow :: forall c s e. GTraversal c s e -> String
showsPrec :: Int -> GTraversal c s e -> ShowS
$cshowsPrec :: forall c s e. Int -> 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) = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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) = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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 = 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
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
showList :: [GraphTraversal c s e] -> ShowS
$cshowList :: forall c s e. [GraphTraversal c s e] -> ShowS
show :: GraphTraversal c s e -> String
$cshow :: forall c s e. GraphTraversal c s e -> String
showsPrec :: Int -> GraphTraversal c s e -> ShowS
$cshowsPrec :: forall c s e. Int -> 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 = 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 = 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 = 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) = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ forall a. Text -> Greskell a
unsafeGreskellLazy forall a b. (a -> b) -> a -> b
$ 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) = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ forall a. Text -> Greskell a
unsafeGreskellLazy forall a b. (a -> b) -> a -> b
$ 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) = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ forall a. Text -> Greskell a
unsafeGreskellLazy forall a b. (a -> b) -> a -> b
$ 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
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
showList :: [Walk c s e] -> ShowS
$cshowList :: forall c s e. [Walk c s e] -> ShowS
show :: Walk c s e -> String
$cshow :: forall c s e. Walk c s e -> String
showsPrec :: Int -> Walk c s e -> ShowS
$cshowsPrec :: forall c s e. Int -> Walk c s e -> ShowS
Show)
instance WalkType c => Category (Walk c) where
id :: forall a. Walk c a a
id = 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) = forall c s e. Text -> Walk c s e
Walk (Text
ab 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
(<>) = 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 = 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 = 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) = 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) = 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) = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ forall a. Text -> Greskell a
unsafeGreskellLazy (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) = 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) = 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) = 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 = forall a. ToGreskell a => a -> Greskell (GreskellReturn a)
toGreskell forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 " forall a. Semigroup a => a -> a -> a
<> forall t. WalkType t => Proxy t -> String
showWalkType Proxy from
f forall a. Semigroup a => a -> a -> a
<> String
" " forall a. Semigroup a => a -> a -> a
<> 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 = 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 = 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 = 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 = 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 " forall a. Semigroup a => a -> a -> a
<> forall t. WalkType t => Proxy t -> String
showWalkType Proxy c
c forall a. Semigroup a => a -> a -> a
<> String
" " forall a. Semigroup a => a -> a -> a
<> 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 = 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 = 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 = forall from to.
(WalkType from, WalkType to) =>
Proxy from -> Proxy to -> String
genericShowSplit
data GraphTraversalSource = GraphTraversalSource deriving (Int -> GraphTraversalSource -> ShowS
[GraphTraversalSource] -> ShowS
GraphTraversalSource -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GraphTraversalSource] -> ShowS
$cshowList :: [GraphTraversalSource] -> ShowS
show :: GraphTraversalSource -> String
$cshow :: GraphTraversalSource -> String
showsPrec :: Int -> GraphTraversalSource -> ShowS
$cshowsPrec :: Int -> GraphTraversalSource -> ShowS
Show)
source :: Text
-> Greskell GraphTraversalSource
source :: Text -> Greskell GraphTraversalSource
source = 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 =
forall a. Text -> Greskell a
unsafeGreskellLazy forall a b. (a -> b) -> a -> b
$ (forall a. ToGreskell a => a -> Text
toGremlinLazy Greskell GraphTraversalSource
src forall a. Semigroup a => a -> a -> a
<> Text -> [Text] -> Text
methodCallText Text
method_name (forall a b. (a -> b) -> [a] -> [b]
map 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 = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ 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' = 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 = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ 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' = 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 = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ 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' = 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 = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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) = forall c s e. Greskell (GraphTraversal c s e) -> GTraversal c s e
GTraversal forall a b. (a -> b) -> a -> b
$ forall a. Text -> Greskell a
unsafeGreskellLazy (forall a. ToGreskell a => a -> Text
toGremlinLazy Greskell (GraphTraversal c a b)
gt 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 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 = forall c b d a. Walk c b d -> GTraversal c a b -> GTraversal c a d
($.) Walk c b d
gs 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 = forall c b d a. Walk c b d -> 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 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"iterate" [] 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
"." forall a. Semigroup a => a -> a -> a
<>) forall a b. (a -> b) -> a -> b
$ forall a. ToGreskell a => a -> Text
toGremlinLazy forall a b. (a -> b) -> a -> b
$ 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 = forall c s e. Text -> Walk c s e
Walk 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 forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall a. Semigroup a => NonEmpty a -> a
sconcat (Walk c e e
m 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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall a b. (a -> b) -> a -> b
$ forall s. Walk Filter s s
gIdentity'
gIdentity' :: Walk Filter s s
gIdentity' :: forall s. Walk Filter s s
gIdentity' = 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 = forall a. ToGreskell a => a -> Text
toGremlin forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c s e. GTraversal c s e -> Greskell (GraphTraversal c s e)
unGTraversal forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"filter" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall s. Walk Filter s s
gCyclicPath'
gCyclicPath' :: Walk Filter a a
gCyclicPath' :: forall s. Walk Filter s s
gCyclicPath' = 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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall s. Walk Filter s s
gSimplePath'
gSimplePath' :: Walk Filter a a
gSimplePath' :: forall s. Walk Filter s s
gSimplePath' = 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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"where" forall a b. (a -> b) -> a -> b
$ [Text]
start_args forall a. [a] -> [a] -> [a]
++ [forall a. ToGreskell a => a -> Text
toGremlin Greskell (LabeledP a)
p]
start_args :: [Text]
start_args = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToGreskell a => a -> Text
toGremlin) Maybe (AsLabel a)
mstart
mods :: [Walk Filter x x]
mods = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall a b. (a -> b) -> a -> b
$ 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 = forall a b x.
Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWherePGeneric 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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall a b. (a -> b) -> a -> b
$ 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 = forall a b x.
Maybe (AsLabel a)
-> Greskell (LabeledP a)
-> Maybe (ByProjection a b)
-> Walk Filter x x
gWherePGeneric (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) = forall (g :: * -> * -> * -> *) c s e1 e2.
(ToGTraversal g, WalkType c) =>
g c s e1 -> g c s e2
unsafeCastEnd forall a b. (a -> b) -> a -> b
$ forall (g :: * -> * -> * -> *) c s1 e s2.
(ToGTraversal g, WalkType c) =>
g c s1 e -> g c s2 e
unsafeCastStart forall a b. (a -> b) -> a -> b
$ forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal (forall a. AsLabel a -> Walk Transform a a
gAs AsLabel a
l 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 = forall a. a -> Logic a
Logic.Leaf forall a b. (a -> b) -> a -> b
$ forall a e. AsLabel a -> Walk Transform a e -> MatchPattern
MatchPattern AsLabel a
l (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 = 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 -> forall a b. (a -> b) -> [a] -> [b]
map (forall a. ToGreskell a => a -> Text
toGremlin forall b c a. (b -> c) -> (a -> b) -> a -> c
. Logic MatchPattern -> GTraversal Transform () ()
toTraversal) (Logic MatchPattern
p forall a. a -> [a] -> [a]
: [Logic MatchPattern]
rest)
Logic MatchPattern
_ -> [forall a. ToGreskell a => a -> Text
toGremlin 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 -> forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal forall a b. (a -> b) -> a -> b
$ forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gAnd forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map Logic MatchPattern -> GTraversal Transform () ()
toTraversal (Logic MatchPattern
p forall a. a -> [a] -> [a]
: [Logic MatchPattern]
rest)
Logic.Or Logic MatchPattern
p [Logic MatchPattern]
rest -> forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal forall a b. (a -> b) -> a -> b
$ forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gOr forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map Logic MatchPattern -> GTraversal Transform () ()
toTraversal (Logic MatchPattern
p forall a. a -> [a] -> [a]
: [Logic MatchPattern]
rest)
Logic.Not Logic MatchPattern
p -> forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> GTraversal c s e
toGTraversal forall a b. (a -> b) -> a -> b
$ forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gNot 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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"is" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"is" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"has" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall a b. (a -> b) -> a -> b
$ 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"has" [forall a. ToGreskell a => a -> Text
toGremlin Key s v
k, 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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall a b. (a -> b) -> a -> b
$ 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"has" [forall a. ToGreskell a => a -> Text
toGremlin Key s v
key, 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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasLabel" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasLabel" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasId" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasId" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasKey" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasKey" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasValue" [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 = forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"hasValue" [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
method_name forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map 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 = 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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"not" [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"range" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"limit" [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"tail" [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"skip" [forall a. ToGreskell a => a -> Text
toGremlin Greskell Int
num]
newtype RepeatLabel
= RepeatLabel { RepeatLabel -> Text
unRepeatLabel :: Text }
deriving (RepeatLabel -> RepeatLabel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepeatLabel -> RepeatLabel -> Bool
$c/= :: RepeatLabel -> RepeatLabel -> Bool
== :: RepeatLabel -> RepeatLabel -> Bool
$c== :: RepeatLabel -> RepeatLabel -> Bool
Eq, String -> RepeatLabel
forall a. (String -> a) -> IsString a
fromString :: String -> RepeatLabel
$cfromString :: String -> RepeatLabel
IsString, Eq 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
min :: RepeatLabel -> RepeatLabel -> RepeatLabel
$cmin :: RepeatLabel -> RepeatLabel -> RepeatLabel
max :: RepeatLabel -> RepeatLabel -> RepeatLabel
$cmax :: RepeatLabel -> RepeatLabel -> RepeatLabel
>= :: RepeatLabel -> RepeatLabel -> Bool
$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
compare :: RepeatLabel -> RepeatLabel -> Ordering
$ccompare :: RepeatLabel -> RepeatLabel -> Ordering
Ord, Int -> RepeatLabel -> ShowS
[RepeatLabel] -> ShowS
RepeatLabel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepeatLabel] -> ShowS
$cshowList :: [RepeatLabel] -> ShowS
show :: RepeatLabel -> String
$cshow :: RepeatLabel -> String
showsPrec :: Int -> RepeatLabel -> ShowS
$cshowsPrec :: Int -> 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
forall a. a -> a -> Bounded a
maxBound :: RepeatPos
$cmaxBound :: RepeatPos
minBound :: RepeatPos
$cminBound :: RepeatPos
Bounded, Int -> RepeatPos
RepeatPos -> Int
RepeatPos -> [RepeatPos]
RepeatPos -> RepeatPos
RepeatPos -> RepeatPos -> [RepeatPos]
RepeatPos -> RepeatPos -> RepeatPos -> [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
enumFromThenTo :: RepeatPos -> RepeatPos -> RepeatPos -> [RepeatPos]
$cenumFromThenTo :: RepeatPos -> RepeatPos -> RepeatPos -> [RepeatPos]
enumFromTo :: RepeatPos -> RepeatPos -> [RepeatPos]
$cenumFromTo :: RepeatPos -> RepeatPos -> [RepeatPos]
enumFromThen :: RepeatPos -> RepeatPos -> [RepeatPos]
$cenumFromThen :: RepeatPos -> RepeatPos -> [RepeatPos]
enumFrom :: RepeatPos -> [RepeatPos]
$cenumFrom :: RepeatPos -> [RepeatPos]
fromEnum :: RepeatPos -> Int
$cfromEnum :: RepeatPos -> Int
toEnum :: Int -> RepeatPos
$ctoEnum :: Int -> RepeatPos
pred :: RepeatPos -> RepeatPos
$cpred :: RepeatPos -> RepeatPos
succ :: RepeatPos -> RepeatPos
$csucc :: RepeatPos -> RepeatPos
Enum, RepeatPos -> RepeatPos -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepeatPos -> RepeatPos -> Bool
$c/= :: RepeatPos -> RepeatPos -> Bool
== :: RepeatPos -> RepeatPos -> Bool
$c== :: RepeatPos -> RepeatPos -> Bool
Eq, Eq 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
min :: RepeatPos -> RepeatPos -> RepeatPos
$cmin :: RepeatPos -> RepeatPos -> RepeatPos
max :: RepeatPos -> RepeatPos -> RepeatPos
$cmax :: RepeatPos -> RepeatPos -> RepeatPos
>= :: RepeatPos -> RepeatPos -> Bool
$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
compare :: RepeatPos -> RepeatPos -> Ordering
$ccompare :: RepeatPos -> RepeatPos -> Ordering
Ord, Int -> RepeatPos -> ShowS
[RepeatPos] -> ShowS
RepeatPos -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepeatPos] -> ShowS
$cshowList :: [RepeatPos] -> ShowS
show :: RepeatPos -> String
$cshow :: RepeatPos -> String
showsPrec :: Int -> RepeatPos -> ShowS
$cshowsPrec :: Int -> 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) = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"times" [forall a. ToGreskell a => a -> Text
toGremlin Greskell Int
count]
makeUntilWalk (RepeatUntilT GTraversal cc s e
trav) = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"until" [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) = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"emit" []
makeEmitWalk (RepeatEmitT GTraversal cc s e
trav) = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"emit" [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
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
showList :: [MWalk c s e] -> ShowS
$cshowList :: forall c s e. [MWalk c s e] -> ShowS
show :: MWalk c s e -> String
$cshow :: forall c s e. MWalk c s e -> String
showsPrec :: Int -> MWalk c s e -> ShowS
$cshowsPrec :: forall c s e. Int -> 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 = forall c s e. Maybe (Walk c s e) -> MWalk c s e
MWalk forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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) = 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 = forall c s. WalkType c => MWalk c s s -> Walk c s s
fromMWalk (MWalk c s s
head_walk forall a. Semigroup a => a -> a -> a
<> forall c s e. Walk c s e -> MWalk c s e
toMWalk Walk c s s
repeat_body forall a. Semigroup a => a -> a -> a
<> MWalk c s s
tail_walk)
where
repeat_body :: Walk c s s
repeat_body = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"repeat" ([Text]
label_args forall a. [a] -> [a] -> [a]
++ [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 = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\RepeatLabel
l -> [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 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 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 -> (forall a. Monoid a => a
mempty, forall a. Monoid a => a
mempty)
Just (RepeatPos
pos, RepeatUntil c s
u) ->
case RepeatPos
pos of
RepeatPos
RepeatHead -> (forall c s e. Walk c s e -> MWalk c s e
toMWalk forall a b. (a -> b) -> a -> b
$ forall c s. WalkType c => RepeatUntil c s -> Walk c s s
makeUntilWalk RepeatUntil c s
u, forall a. Monoid a => a
mempty)
RepeatPos
RepeatTail -> (forall a. Monoid a => a
mempty, forall c s e. Walk c s e -> MWalk c s e
toMWalk forall a b. (a -> b) -> a -> b
$ 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 -> (forall a. Monoid a => a
mempty, forall a. Monoid a => a
mempty)
Just (RepeatPos
pos, RepeatEmit c s
e) ->
case RepeatPos
pos of
RepeatPos
RepeatHead -> (forall c s e. Walk c s e -> MWalk c s e
toMWalk forall a b. (a -> b) -> a -> b
$ forall c s. WalkType c => RepeatEmit c s -> Walk c s s
makeEmitWalk RepeatEmit c s
e, forall a. Monoid a => a
mempty)
RepeatPos
RepeatTail -> (forall a. Monoid a => a
mempty, forall c s e. Walk c s e -> MWalk c s e
toMWalk forall a b. (a -> b) -> a -> b
$ 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 = forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, 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 = forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatUntil c s
RepeatUntilT forall a b. (a -> b) -> a -> b
$ 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 = forall a. a -> Maybe a
Just (RepeatPos
RepeatTail, forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatUntil c s
RepeatUntilT forall a b. (a -> b) -> a -> b
$ 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 = forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, forall c s. RepeatEmit c s
RepeatEmit)
gEmitTail :: Maybe (RepeatPos, RepeatEmit c s)
gEmitTail :: forall c s. Maybe (RepeatPos, RepeatEmit c s)
gEmitTail = forall a. a -> Maybe a
Just (RepeatPos
RepeatTail, 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 = forall a. a -> Maybe a
Just (RepeatPos
RepeatHead, forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatEmit c s
RepeatEmitT forall a b. (a -> b) -> a -> b
$ 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 = forall a. a -> Maybe a
Just (RepeatPos
RepeatTail, forall a c s e.
(WalkType a, WalkType c, Split a c) =>
GTraversal a s e -> RepeatEmit c s
RepeatEmitT forall a b. (a -> b) -> a -> b
$ 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"loops" forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\RepeatLabel
l -> [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"local" [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"union" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"coalesce" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"choose"
[ forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g cc s ep
pt,
forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Text
travToG g c s e
tt,
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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"barrier" forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Greskell Int
m -> [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 = 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 = forall a b s.
[Text] -> Maybe (ByProjection a b) -> Walk Transform s s
gDedupGeneric (forall a b. (a -> b) -> [a] -> [b]
map forall a. ToGreskell a => a -> Text
toGremlin (AsLabel a
l 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) -> 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 [forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [forall a. ToGreskell a => a -> Text
toGremlin p
g]]
where
main_walk :: Walk Transform s s
main_walk = 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 = forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
ByProjection forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s e. String -> Key s e
toKey
where
toKey :: String -> Key s e
toKey :: forall s e. String -> Key s e
toKey = 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 = 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 = forall s a. ByProjection s a -> ByComparator s
ByComparatorProj forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall s a. ByProjection s a -> ByComparator s
ByComparatorProj forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall a s.
Comparator a =>
ByProjection s (CompareArg a) -> Greskell a -> ByComparator s
ByComparatorProjComp (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 = forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith forall {s} {e}. Walk Transform s e
order_step [Walk Transform s s]
by_steps
where
order_step :: Walk Transform s e
order_step = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"order" []
by_steps :: [Walk Transform s s]
by_steps = forall a b. (a -> b) -> [a] -> [b]
map (forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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) -> [forall a. ToGreskell a => a -> Text
toGremlin p
p]
ByComparatorComp Greskell comp
comp -> [forall a. ToGreskell a => a -> Text
toGremlin Greskell comp
comp]
ByComparatorProjComp (ByProjection p
p) Greskell comp
comp -> [forall a. ToGreskell a => a -> Text
toGremlin p
p, 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 = forall a s. AsLabel a -> ByProjection s a -> LabeledByProjection s
LabeledByProjection AsLabel (ProjectionLikeEnd p)
l forall a b. (a -> b) -> a -> b
$ 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"flatMap" [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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"V" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map 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' = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"constant" [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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"as" [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"values" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"properties" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map 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 = 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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"valueMap" forall a b. (a -> b) -> a -> b
$ 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"elementMap" forall a b. (a -> b) -> a -> b
$ 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"select" [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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"select" ([forall a. ToGreskell a => a -> Text
toGremlin AsLabel a
l1, forall a. ToGreskell a => a -> Text
toGremlin AsLabel b
l2] forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map 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) = 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) = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [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 = forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (forall c a b b'. Walk c a b -> Walk c a b'
unsafeChangeEnd forall a b. (a -> b) -> a -> b
$ forall a s. AsLabel a -> Walk Transform s a
gSelect1 AsLabel a
l) [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 = forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (forall c a b b'. Walk c a b -> Walk c a b'
unsafeChangeEnd forall a b. (a -> b) -> a -> b
$ 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) [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 = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' forall {a} {c} {s}.
Walk Transform a c -> LabeledByProjection s -> Walk Transform a c
f (forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"project" [Text]
labels) (LabeledByProjection s
lp_head forall a. a -> [a] -> [a]
: [LabeledByProjection s]
lps)
where
labels :: [Text]
labels = forall a b. (a -> b) -> [a] -> [b]
map forall {s}. LabeledByProjection s -> Text
toLabelGremlin (LabeledByProjection s
lp_head forall a. a -> [a] -> [a]
: [LabeledByProjection s]
lps)
toLabelGremlin :: LabeledByProjection s -> Text
toLabelGremlin (LabeledByProjection AsLabel a
l ByProjection s a
_) = 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 forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a 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)) = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [forall a. ToGreskell a => a -> Text
toGremlin p
p]
gPath :: Walk Transform s (Path GValue)
gPath :: forall s. Walk Transform s (Path GValue)
gPath = 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 = forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"path" []) forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall t a b c. WalkType t => ByProjection a b -> Walk t c c
byStep forall a b. (a -> b) -> a -> b
$ ByProjection a b
b1 forall a. a -> [a] -> [a]
: [ByProjection a b]
bn
gFold :: Walk Transform a [a]
gFold :: forall a. Walk Transform a [a]
gFold = 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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
method_name forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map 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 = 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' = 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 = 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' = 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 = 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' = 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 = 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' = 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 = 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' = 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 = 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' = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"sideEffect" [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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"addV" [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' = 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 = 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 = 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"property" [forall a. ToGreskell a => a -> Text
toGremlin Key e v
key, 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 = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"property" ([Text]
arg_card forall a. [a] -> [a] -> [a]
++ [Text]
arg_keyval forall a. [a] -> [a] -> [a]
++ [Text]
arg_metaprops)
where
arg_card :: [Text]
arg_card = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Greskell Cardinality
card -> [forall a. ToGreskell a => a -> Text
toGremlin Greskell Cardinality
card]) Maybe (Greskell Cardinality)
mcard
arg_keyval :: [Text]
arg_keyval = [forall a. ToGreskell a => a -> Text
toGremlin Key e v
key, forall a. ToGreskell a => a -> Text
toGremlin Greskell v
val]
arg_metaprops :: [Text]
arg_metaprops = forall {a}. KeyValue a -> [Text]
expand 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) = [forall a. ToGreskell a => a -> Text
toGremlin Key a b
meta_key, 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) = forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
step_name [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 = forall s e. Text -> GTraversal Transform s e -> AddAnchor s e
AddAnchor Text
"from" forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall s e. Text -> GTraversal Transform s e -> AddAnchor s e
AddAnchor Text
"to" forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = (forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"addE" [forall a. ToGreskell a => a -> Text
toGremlin Greskell Text
label]) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> 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' = 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 =
[ ( forall a. ToGreskell a => a -> Text
toGremlin forall a b. (a -> b) -> a -> b
$ Text -> Greskell GraphTraversalSource
source Text
"g"
, Text
"g"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' (forall a b. (a -> b) -> [a] -> [b]
map (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall e. GValue -> ElementID e
ElementID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Integral a => a -> Greskell GValue
gvalueInt) ([Int
1,Int
2,Int
3] :: [Int])))
, Text
"g.V(1,2,3)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
sE' (forall a b. (a -> b) -> [a] -> [b]
map (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall e. GValue -> ElementID e
ElementID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Integral a => a -> Greskell GValue
gvalueInt) ([Int
1] :: [Int])))
, Text
"g.E(1)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& Greskell Text
-> Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex
sAddV' Greskell Text
"person")
, Text
"g.addV(\"person\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin forall a b. (a -> b) -> a -> b
$ forall c s e. Text -> GTraversal c s e
unsafeGTraversal Text
"g.V().count()"
, Text
"g.V().count()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Any
"age"])
, Text
"g.V().values(\"age\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Any
"age"] 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' [] forall a b. (a -> b) -> a -> b
$ Text -> Greskell GraphTraversalSource
source Text
"g")
, Text
"g.V().values(\"age\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& Greskell Text
-> Greskell GraphTraversalSource
-> GTraversal SideEffect () AVertex
sAddV' Greskell Text
"person" forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall e v.
Element e =>
Key e v -> Greskell v -> Walk SideEffect e e
gProperty Key AVertex Text
"name" (Greskell Text
"marko" :: Greskell Text) forall a b. a -> (a -> b) -> b
& forall c s e. WalkType c => GTraversal c s e -> GTraversal c s ()
gIterate)
, Text
"g.addV(\"person\").property(\"name\",\"marko\").iterate()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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')"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall c s e.
WalkType c =>
Walk c s e -> [Walk c e e] -> Walk c s e
modulateWith (forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"path" []) [forall c s e. WalkType c => Text -> [Text] -> Walk c s e
unsafeWalk Text
"by" [Text
"'name'"], 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')"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gFilter (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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
la forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall c a b.
WalkType c =>
Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c a a
gWhereP1 (forall p. PLike p => PParameter p -> Greskell p
pEq AsLabel AVertex
la) (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
la forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
lb forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
age] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall c a b x.
WalkType c =>
AsLabel a
-> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c x x
gWhereP2 AsLabel AVertex
la (forall p. PLike p => PParameter p -> Greskell p
pEq AsLabel AVertex
lb) 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 =
forall a. Logic a -> [Logic a] -> Logic a
Logic.And
( forall c a b.
(WalkType c, Lift c Transform) =>
AsLabel a -> Walk c a b -> Logic MatchPattern
mPattern AsLabel AVertex
label_a (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
label_b) )
[ forall c a b.
(WalkType c, Lift c Transform) =>
AsLabel a -> Walk c a b -> Logic MatchPattern
mPattern AsLabel AVertex
label_b (forall s v. Element s => Key s v -> Greskell v -> Walk Filter s s
gHas2' Key AVertex Int
key_age Greskell Int
25) ]
in forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. Logic MatchPattern -> Walk Transform a MatchResult
gMatch Logic MatchPattern
patterns forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
"age" :: Key AVertex Int] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall c v. WalkType c => Greskell v -> Walk c v v
gIs Greskell Int
30)
, Text
"g.V().values(\"age\").is(30)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
"age" :: Key AVertex Int] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall c v. WalkType c => Greskell (P v) -> Walk c v v
gIsP (forall p. PLike p => PParameter p -> Greskell p
pLte Greskell Int
30))
, Text
"g.V().values(\"age\").is(P.lte(30))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall c s v.
(WalkType c, Element s) =>
Key s v -> Greskell (P v) -> Walk c s s
gHas2P Key AVertex Int
"age" (forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pBetween (Greskell Int
30 :: Greskell Int) Greskell Int
40))
, Text
"g.V().has(\"age\",P.between(30,40))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s c. (Element s, WalkType c) => Greskell Text -> Walk c s s
gHasLabel Greskell Text
"person")
, Text
"g.V().hasLabel(\"person\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s c.
(Element s, WalkType c) =>
Greskell (P Text) -> Walk c s s
gHasLabelP (forall p. PLike p => PParameter p -> Greskell p
pEq Greskell Text
"person"))
, Text
"g.V().hasLabel(P.eq(\"person\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s c.
(Element s, WalkType c) =>
Greskell (ElementID s) -> Walk c s s
gHasId (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall e. GValue -> ElementID e
ElementID forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Greskell GValue
gvalueInt forall a b. (a -> b) -> a -> b
$ (Int
7 :: Int)))
, Text
"g.V().hasId(7)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s c.
(Element s, WalkType c) =>
Greskell (P (ElementID s)) -> Walk c s s
gHasIdP (forall p. PLike p => PParameter p -> Greskell p
pLte forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall e. GValue -> ElementID e
ElementID forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Greskell GValue
gvalueInt (Int
100 :: Int)))
, Text
"g.V().hasId(P.lte(100))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [Key AVertex Int
"age"] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [Key AVertex Int
"age"] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (p :: * -> *) v c.
(Element (p v), Property p, WalkType c) =>
Greskell (P v) -> Walk c (p v) (p v)
gHasValueP (forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pBetween (Greskell Int
30 :: Greskell Int) Greskell Int
40))
, Text
"g.V().properties(\"age\").hasValue(P.between(30,40))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gAnd [forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"], 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\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
[g c s e] -> Walk p s s
gOr [forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"], 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\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (g :: * -> * -> * -> *) c p s e.
(ToGTraversal g, WalkType c, WalkType p, Split c p) =>
g c s e -> Walk p s s
gNot (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"]))
, Text
"g.V().not(__.out(\"knows\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s. Greskell Int -> Greskell Int -> Walk Transform s s
gRange Greskell Int
0 Greskell Int
100)
, Text
"g.V().range(0,100)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. Maybe a
Nothing (forall c s. Greskell Int -> Maybe (RepeatPos, RepeatUntil c s)
gTimes Greskell Int
3) forall a. Maybe a
Nothing (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().times(3).repeat(__.out())"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. Maybe a
Nothing (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 forall a b. (a -> b) -> a -> b
$ forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") forall a. Maybe a
Nothing (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().until(__.hasLabel(\"person\")).repeat(__.out())"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. Maybe a
Nothing (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 forall a b. (a -> b) -> a -> b
$ forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") forall a. Maybe a
Nothing (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().repeat(__.out()).until(__.hasLabel(\"person\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall c s. Maybe (RepeatPos, RepeatEmit c s)
gEmitHead (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().emit().repeat(__.out())"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall c s. Maybe (RepeatPos, RepeatEmit c s)
gEmitTail (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().repeat(__.out()).emit()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. Maybe a
Nothing forall a. Maybe a
Nothing (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 forall a b. (a -> b) -> a -> b
$ forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().emit(__.hasLabel(\"person\")).repeat(__.out())"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. Maybe a
Nothing forall a. Maybe a
Nothing (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 forall a b. (a -> b) -> a -> b
$ forall s. Element s => Greskell Text -> Walk Filter s s
gHasLabel' Greskell Text
"person") (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 = forall a. a -> Maybe a
Just RepeatLabel
"the_loop"
in forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 (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 forall a b. (a -> b) -> a -> b
$ forall s. Maybe RepeatLabel -> Walk Transform s Int
gLoops Maybe RepeatLabel
loop_label forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall c v. WalkType c => Greskell v -> Walk c v v
gIs Greskell Int
3) forall a. Maybe a
Nothing (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().repeat(\"the_loop\",__.out()).until(__.loops(\"the_loop\").is(3))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
g c s e -> Walk c s e
gLocal ( forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c) =>
[g c s e] -> Walk c s e
gUnion [forall s e. Element s => [Key s e] -> Walk Transform s e
gValues [Key AVertex Int
key_age], 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\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 [forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [], 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 (forall s v. Element s => Key s v -> Greskell v -> Walk Filter s s
gHas2' Key AVertex Int
key_age Greskell Int
30) (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gIn' []) (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' []))
, Text
"g.V().choose(__.has(\"age\",30),__.in(),__.out())"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s e. Maybe (ByProjection s e) -> Walk Transform s s
gDedup 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s e. Maybe (ByProjection s e) -> Walk Transform s s
gDedup (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
label_a forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. AsLabel a -> Walk Transform a a
gAs AsLabel AVertex
label_b forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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] 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s. [ByComparator s] -> Walk Transform s s
gOrder [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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s. [ByComparator s] -> Walk Transform s s
gOrder [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 forall a. Greskell (Order a)
oDecr, forall p.
(ProjectionLike p, ToGreskell p) =>
p -> ByComparator (ProjectionLikeStart p)
gBy1 forall a. Element a => Greskell (T a (ElementID a))
tId])
, Text
"g.V().order().by(\"age\",Order.decr).by(T.id)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s. [ByComparator s] -> Walk Transform s s
gOrder [forall p comp.
(ProjectionLike p, ToGreskell p, Comparator comp,
ProjectionLikeEnd p ~ CompareArg comp) =>
p -> Greskell comp -> ByComparator (ProjectionLikeStart p)
gBy2 (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"] forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall a. Walk Transform a Int
gCount) forall a. Greskell (Order a)
oIncr, forall p comp.
(ProjectionLike p, ToGreskell p, Comparator comp,
ProjectionLikeEnd p ~ CompareArg comp) =>
p -> Greskell comp -> ByComparator (ProjectionLikeStart p)
gBy2 forall a. Element a => Greskell (T a (ElementID a))
tId forall a. Greskell (Order a)
oIncr])
, Text
"g.V().order().by(__.out(\"knows\").count(),Order.incr).by(T.id,Order.incr)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s. [ByComparator s] -> Walk Transform s s
gOrder [ByComparator AVertex
"age"])
, Text
"g.V().order().by(\"age\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"] forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"created"]))
, Text
"g.V().flatMap(__.out(\"knows\").out(\"created\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a s. Greskell a -> Walk Transform s a
gConstant (Greskell Int
10 :: Greskell Int))
, Text
"g.V().constant(10)"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. Walk Transform a [a]
gFold forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a. AsIterator a => Walk Transform a (IteratorItem a)
gUnfold)
, Text
"g.V().fold().unfold()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s.
Element s =>
Keys s
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
gValueMap forall a. Keys a
KeysNil)
, Text
"g.V().valueMap()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s.
Element s =>
Keys s
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
gValueMap (Key AVertex Any
"name" forall a b. Key a b -> Keys a -> Keys a
-: Key AVertex Any
"age" forall a b. Key a b -> Keys a -> Keys a
-: forall a. Keys a
KeysNil))
, Text
"g.V().valueMap(\"name\",\"age\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s.
Element s =>
Keys s -> Walk Transform s (SelectedMap GValue)
gElementMap forall a. Keys a
KeysNil)
, Text
"g.V().elementMap()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s.
Element s =>
Keys s -> Walk Transform s (SelectedMap GValue)
gElementMap (Key AVertex Any
"name" forall a b. Key a b -> Keys a -> Keys a
-: Key AVertex Any
"age" forall a b. Key a b -> Keys a -> Keys a
-: 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s.
LabeledByProjection s
-> [LabeledByProjection s] -> Walk Transform s (SelectedMap GValue)
gProject (forall p.
(ProjectionLike p, ToGreskell p) =>
AsLabel (ProjectionLikeEnd p)
-> p -> LabeledByProjection (ProjectionLikeStart p)
gByL AsLabel Text
name_label Key AVertex Text
name_key) [forall p.
(ProjectionLike p, ToGreskell p) =>
AsLabel (ProjectionLikeEnd p)
-> p -> LabeledByProjection (ProjectionLikeStart p)
gByL AsLabel Int
count_label (forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall a. Walk Transform a Int
gCount), forall p.
(ProjectionLike p, ToGreskell p) =>
AsLabel (ProjectionLikeEnd p)
-> p -> LabeledByProjection (ProjectionLikeStart p)
gByL AsLabel (ElementID AVertex)
"c" 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 = forall v. Vertex v => [Greskell Text] -> Walk Transform v AEdge
gInE' [] :: Walk Transform AVertex AEdge
in forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall a b s.
ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b)
gPathBy ByProjection AVertex Any
"name" [forall a.
(ProjectionLike a, ToGreskell a) =>
a -> ByProjection (ProjectionLikeStart a) (ProjectionLikeEnd a)
gBy forall a b. (a -> b) -> a -> b
$ Walk Transform AVertex AEdge
inE forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> 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\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall e. GValue -> ElementID e
ElementID forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Greskell GValue
gvalueInt (Int
8 :: Int)] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall v. Vertex v => [Greskell Text] -> Walk Transform v AVertex
gOut' [Greskell Text
"knows"])
, Text
"g.V(8).out(\"knows\")"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall a b. a -> (a -> b) -> b
& forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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) forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c, Split c SideEffect) =>
g c s e -> Walk SideEffect s s
gSideEffect' (forall a. Greskell Text -> Walk SideEffect a AVertex
gAddV' Greskell Text
"toshio"))
, Text
"g.V().has(\"name\",\"marko\").sideEffect(__.addV(\"toshio\"))"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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) forall a b. a -> (a -> b) -> b
& forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall e. Element e => Walk SideEffect e e
gDrop)
, Text
"g.V().has(\"name\",\"marko\").drop()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
sE' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall s (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
gProperties [Key AEdge Any
"weight"] forall a b. a -> (a -> b) -> b
& forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. forall (p :: * -> *) a. Property p => Walk SideEffect (p a) (p a)
gDropP)
, Text
"g.E().properties(\"weight\").drop()"
)
, ( forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall a b. a -> (a -> b) -> b
& forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall a b. a -> (a -> b) -> b
& forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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 (forall a. a -> Maybe a
Just Greskell Cardinality
cList) Key AVertex Text
key_location Greskell Text
"New York" [Key (AVertexProperty Text) Text
key_since forall a b. Key a b -> Greskell b -> KeyValue a
=: Greskell Text
"2012-09-23", Key (AVertexProperty Text) Int
key_score 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall a b. a -> (a -> b) -> b
& forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk 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" (forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
gFrom forall a b. (a -> b) -> a -> b
$ forall s.
[Greskell (ElementID AVertex)] -> Walk Transform s AVertex
gV' [] forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> 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 forall a. ToGreskell a => a -> Text
toGremlin (Text -> Greskell GraphTraversalSource
source Text
"g" forall a b. a -> (a -> b) -> b
& [Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
sV' [] forall c a b d. GTraversal c a b -> Walk c b d -> GTraversal c a d
&. 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" forall a b. a -> (a -> b) -> b
& forall (g :: * -> * -> * -> *) from to s e.
(ToGTraversal g, WalkType from, WalkType to, Lift from to) =>
g from s e -> g to s e
liftWalk 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" (forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
gTo forall a b. (a -> b) -> a -> b
$ forall s.
[Greskell (ElementID AVertex)] -> Walk Transform s AVertex
gV' []))
, Text
"g.V().has(\"name\",\"marko\").addE(\"knows\").to(__.V())"
)
]