{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeFamilies     #-}
-- | __This module is experimental. It may have breaking changes in future.__
--
-- This module has Gremlin traversals defined in 'Data.Greskell.GTraversal' generalized on the
-- walk type. It may save you from calling 'liftWalk' manually.
--
-- @since 2.0.3.0
module Data.Greskell.GTraversal.Gen
    ( -- * Types
      -- ** GraphTraversal and others
      GTraversal (..)
    , GraphTraversal
    , ToGTraversal (..)
    , Walk
    , GraphTraversalSource
      -- ** Walk types
    , WalkType
    , Filter
    , Transform
    , SideEffect
    , Lift
    , Split
      -- * GraphTraversalSource
    , source
    , sV
    , sV'
    , sE
    , sE'
    , sAddV
    , sAddV'
      -- * GTraversal
    , (&.)
    , ($.)
    , (<$.>)
    , (<*.>)
    , gIterate
    , unsafeGTraversal
      -- * Walk/Steps
    , unsafeWalk
    , modulateWith
      -- ** Filter steps
    , gIdentity
    , gFilter
    , gCyclicPath
    , gSimplePath
      -- ** Is step
    , gIs
    , gIsP
      -- ** Has steps
    , gHas1
    , gHas2
    , gHas2P
    , gHasLabel
    , gHasLabelP
    , gHasId
    , gHasIdP
    , gHasKey
    , gHasKeyP
    , gHasValue
    , gHasValueP
      -- ** Logic steps
    , gAnd
    , gOr
    , gNot
      -- ** Where step
    , gWhereP1
    , gWhereP2
      -- ** Sorting steps
    , gOrder
      -- ** Paging steps
    , gRange
    , gLimit
    , gTail
    , gSkip
      -- ** Repeat step
    , gRepeat
    , gTimes
    , gUntilHead
    , gUntilTail
    , gEmitHead
    , gEmitTail
    , gEmitHeadT
    , gEmitTailT
    , gLoops
    , RepeatUntil (..)
    , RepeatEmit (..)
    , RepeatPos (..)
    , RepeatLabel (..)
      -- ** Branching steps
    , gLocal
    , gUnion
    , gCoalesce
    , gChoose3
      -- ** Barrier steps
    , gBarrier
    , gDedup
    , gDedupN
      -- ** Transformation steps
    , gFlatMap
    , gV
    , gV'
    , gConstant
    , gProject
      -- ** As step
    , gAs
      -- ** Accessor steps
    , gValues
    , gProperties
    , gId
    , gLabel
    , gValueMap
    , gElementMap
    , gSelect1
    , gSelectN
    , gSelectBy1
    , gSelectByN
    , gUnfold
    , gPath
    , gPathBy
      -- ** Summarizing steps
    , gFold
    , gCount
      -- ** Graph traversal steps
    , gOut
    , gOut'
    , gOutE
    , gOutE'
    , gOutV
    , gOutV'
    , gIn
    , gIn'
    , gInE
    , gInE'
    , gInV
    , gInV'
      -- ** Match step
    , gMatch
    , MatchPattern (..)
    , mPattern
    , MatchResult
      -- ** Side-effect steps
    , gSideEffect
      -- ** Graph manipulation steps
    , gAddV
    , gAddV'
    , gAddE
    , gAddE'
    , AddAnchor
    , gFrom
    , gTo
    , gDrop
    , gDropP
    , gProperty
    , gPropertyV
      -- ** @.by@ steps
    , ByProjection (..)
    , ProjectionLike (..)
    , ByComparator (..)
    , LabeledByProjection (..)
    , gBy
    , gBy1
    , gBy2
    , gByL
    ) where

import           Data.Text                (Text)

import           Data.Greskell.AsIterator (AsIterator (IteratorItem))
import           Data.Greskell.AsLabel    (AsLabel, LabeledP, SelectedMap)
import           Data.Greskell.Graph      (AEdge, AVertex, Cardinality, Edge, Element (..),
                                           ElementID, Key, KeyValue, Keys, Path, Property, Vertex)
import           Data.Greskell.GraphSON   (GValue)
import           Data.Greskell.Greskell   (Greskell)
import           Data.Greskell.GTraversal (AddAnchor, ByComparator (..), ByProjection (..), Filter,
                                           GTraversal (..), GraphTraversal, GraphTraversalSource,
                                           LabeledByProjection (..), Lift, MatchPattern (..),
                                           MatchResult, ProjectionLike (..), RepeatEmit (..),
                                           RepeatLabel (..), RepeatPos (..), RepeatUntil (..),
                                           SideEffect, Split, ToGTraversal (..), Transform, Walk,
                                           WalkType, gAnd, gBarrier, gBy, gBy1, gBy2, gByL,
                                           gChoose3, gCoalesce, gCyclicPath, gEmitHead, gEmitHeadT,
                                           gEmitTail, gEmitTailT, gFilter, gFlatMap, gHas1, gHas2,
                                           gHas2P, gHasId, gHasIdP, gHasKey, gHasKeyP, gHasLabel,
                                           gHasLabelP, gHasValue, gHasValueP, gIdentity, gIs, gIsP,
                                           gIterate, gLocal, gNot, gOr, gRepeat, gSideEffect,
                                           gSimplePath, gTimes, gUnion, gUntilHead, gUntilTail,
                                           gWhereP1, gWhereP2, mPattern, modulateWith, source,
                                           unsafeGTraversal, unsafeWalk, ($.), (&.), (<$.>), (<*.>))
import qualified Data.Greskell.GTraversal as G
import           Data.Greskell.Logic      (Logic)
import           Data.Greskell.PMap       (PMap, Single)

sV :: (Vertex v, WalkType c, Lift Transform c) => [Greskell (ElementID v)] -> Greskell GraphTraversalSource -> GTraversal c () v
sV :: forall v c.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell (ElementID v)]
-> Greskell GraphTraversalSource -> GTraversal c () v
sV [Greskell (ElementID v)]
a Greskell GraphTraversalSource
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 v.
Vertex v =>
[Greskell (ElementID v)]
-> Greskell GraphTraversalSource -> GTraversal Transform () v
G.sV [Greskell (ElementID v)]
a Greskell GraphTraversalSource
b

sV' :: (WalkType c, Lift Transform c) => [Greskell (ElementID AVertex)] -> Greskell GraphTraversalSource -> GTraversal c () AVertex
sV' :: forall c.
(WalkType c, Lift Transform c) =>
[Greskell (ElementID AVertex)]
-> Greskell GraphTraversalSource -> GTraversal c () AVertex
sV' = forall v c.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell (ElementID v)]
-> Greskell GraphTraversalSource -> GTraversal c () v
sV

sE :: (Edge e, WalkType c, Lift Transform c) => [Greskell (ElementID e)] -> Greskell GraphTraversalSource -> GTraversal c () e
sE :: forall e c.
(Edge e, WalkType c, Lift Transform c) =>
[Greskell (ElementID e)]
-> Greskell GraphTraversalSource -> GTraversal c () e
sE [Greskell (ElementID e)]
a Greskell GraphTraversalSource
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 e.
Edge e =>
[Greskell (ElementID e)]
-> Greskell GraphTraversalSource -> GTraversal Transform () e
G.sE [Greskell (ElementID e)]
a Greskell GraphTraversalSource
b

sE' :: (WalkType c, Lift Transform c) => [Greskell (ElementID AEdge)] -> Greskell GraphTraversalSource -> GTraversal c () AEdge
sE' :: forall c.
(WalkType c, Lift Transform c) =>
[Greskell (ElementID AEdge)]
-> Greskell GraphTraversalSource -> GTraversal c () AEdge
sE' = forall e c.
(Edge e, WalkType c, Lift Transform c) =>
[Greskell (ElementID e)]
-> Greskell GraphTraversalSource -> GTraversal c () e
sE

sAddV :: (Vertex v, WalkType c, Lift SideEffect c) => Greskell Text -> Greskell GraphTraversalSource -> GTraversal c () v
sAddV :: forall v c.
(Vertex v, WalkType c, Lift SideEffect c) =>
Greskell Text -> Greskell GraphTraversalSource -> GTraversal c () v
sAddV Greskell Text
a Greskell GraphTraversalSource
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 v.
Vertex v =>
Greskell Text
-> Greskell GraphTraversalSource -> GTraversal SideEffect () v
G.sAddV Greskell Text
a Greskell GraphTraversalSource
b

sAddV' :: (WalkType c, Lift SideEffect c) => Greskell Text -> Greskell GraphTraversalSource -> GTraversal c () AVertex
sAddV' :: forall c.
(WalkType c, Lift SideEffect c) =>
Greskell Text
-> Greskell GraphTraversalSource -> GTraversal c () AVertex
sAddV' = forall v c.
(Vertex v, WalkType c, Lift SideEffect c) =>
Greskell Text -> Greskell GraphTraversalSource -> GTraversal c () v
sAddV

gOrder :: (WalkType c, Lift Transform c) => [ByComparator s] -> Walk c s s
gOrder :: forall c s.
(WalkType c, Lift Transform c) =>
[ByComparator s] -> Walk c s s
gOrder [ByComparator s]
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 s. [ByComparator s] -> Walk Transform s s
G.gOrder [ByComparator s]
b

gRange :: (WalkType c, Lift Transform c) => Greskell Int -> Greskell Int -> Walk c s s
gRange :: forall c s.
(WalkType c, Lift Transform c) =>
Greskell Int -> Greskell Int -> Walk c s s
gRange Greskell Int
a Greskell Int
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 s. Greskell Int -> Greskell Int -> Walk Transform s s
G.gRange Greskell Int
a Greskell Int
b

gLimit :: (WalkType c, Lift Transform c) => Greskell Int -> Walk c s s
gLimit :: forall c s.
(WalkType c, Lift Transform c) =>
Greskell Int -> Walk c s s
gLimit Greskell Int
a = 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. Greskell Int -> Walk Transform s s
G.gLimit Greskell Int
a

gTail :: (WalkType c, Lift Transform c) => Greskell Int -> Walk c s s
gTail :: forall c s.
(WalkType c, Lift Transform c) =>
Greskell Int -> Walk c s s
gTail Greskell Int
a = 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. Greskell Int -> Walk Transform s s
G.gTail Greskell Int
a

gSkip :: (WalkType c, Lift Transform c) => Greskell Int -> Walk c s s
gSkip :: forall c s.
(WalkType c, Lift Transform c) =>
Greskell Int -> Walk c s s
gSkip Greskell Int
a = 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. Greskell Int -> Walk Transform s s
G.gSkip Greskell Int
a

gLoops :: (WalkType c, Lift Transform c) => Maybe RepeatLabel -> Walk c s Int
gLoops :: forall c s.
(WalkType c, Lift Transform c) =>
Maybe RepeatLabel -> Walk c s Int
gLoops Maybe RepeatLabel
a = 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. Maybe RepeatLabel -> Walk Transform s Int
G.gLoops Maybe RepeatLabel
a

gDedup :: (WalkType c, Lift Transform c) => Maybe (ByProjection s e) -> Walk c s s
gDedup :: forall c s e.
(WalkType c, Lift Transform c) =>
Maybe (ByProjection s e) -> Walk c s s
gDedup Maybe (ByProjection s e)
a =  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 e. Maybe (ByProjection s e) -> Walk Transform s s
G.gDedup Maybe (ByProjection s e)
a

gDedupN :: (WalkType c, Lift Transform c) => AsLabel a -> [AsLabel a] -> Maybe (ByProjection a e) -> Walk c s s
gDedupN :: forall c a e s.
(WalkType c, Lift Transform c) =>
AsLabel a -> [AsLabel a] -> Maybe (ByProjection a e) -> Walk c s s
gDedupN AsLabel a
a [AsLabel a]
b Maybe (ByProjection a e)
c = 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 e s.
AsLabel a
-> [AsLabel a] -> Maybe (ByProjection a e) -> Walk Transform s s
G.gDedupN AsLabel a
a [AsLabel a]
b Maybe (ByProjection a e)
c

gV :: (Vertex v, WalkType c, Lift Transform c) => [Greskell (ElementID v)] -> Walk c s v
gV :: forall v c s.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell (ElementID v)] -> Walk c s v
gV [Greskell (ElementID v)]
a = 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 v s.
Vertex v =>
[Greskell (ElementID v)] -> Walk Transform s v
G.gV [Greskell (ElementID v)]
a

gV' :: (WalkType c, Lift Transform c) => [Greskell (ElementID AVertex)] -> Walk c s AVertex
gV' :: forall c s.
(WalkType c, Lift Transform c) =>
[Greskell (ElementID AVertex)] -> Walk c s AVertex
gV' = forall v c s.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell (ElementID v)] -> Walk c s v
gV

gConstant :: (WalkType c, Lift Transform c) => Greskell a -> Walk c s a
gConstant :: forall c a s.
(WalkType c, Lift Transform c) =>
Greskell a -> Walk c s a
gConstant Greskell a
a = 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 s. Greskell a -> Walk Transform s a
G.gConstant Greskell a
a

gProject :: (WalkType c, Lift Transform c) => LabeledByProjection s -> [LabeledByProjection s] -> Walk c s (PMap Single GValue)
gProject :: forall c s.
(WalkType c, Lift Transform c) =>
LabeledByProjection s
-> [LabeledByProjection s] -> Walk c s (PMap Single GValue)
gProject LabeledByProjection s
a [LabeledByProjection s]
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 s.
LabeledByProjection s
-> [LabeledByProjection s] -> Walk Transform s (PMap Single GValue)
G.gProject LabeledByProjection s
a [LabeledByProjection s]
b

gAs :: (WalkType c, Lift Transform c) => AsLabel a -> Walk c a a
gAs :: forall c a.
(WalkType c, Lift Transform c) =>
AsLabel a -> Walk c a a
gAs AsLabel a
a = 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. AsLabel a -> Walk Transform a a
G.gAs AsLabel a
a

gValues :: (Element s, WalkType c, Lift Transform c) => [Key s e] -> Walk c s e
gValues :: forall s c e.
(Element s, WalkType c, Lift Transform c) =>
[Key s e] -> Walk c s e
gValues [Key s e]
a = 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 e. Element s => [Key s e] -> Walk Transform s e
G.gValues [Key s e]
a

gProperties :: (Element s, Property p, ElementProperty s ~ p, WalkType c, Lift Transform c) => [Key s v] -> Walk c s (p v)
gProperties :: forall s (p :: * -> *) c v.
(Element s, Property p, ElementProperty s ~ p, WalkType c,
 Lift Transform c) =>
[Key s v] -> Walk c s (p v)
gProperties [Key s v]
a = 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 (p :: * -> *) v.
(Element s, Property p, ElementProperty s ~ p) =>
[Key s v] -> Walk Transform s (p v)
G.gProperties [Key s v]
a

gId :: (Element s, WalkType c, Lift Transform c) => Walk c s (ElementID s)
gId :: forall s c.
(Element s, WalkType c, Lift Transform c) =>
Walk c s (ElementID s)
gId = 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. Element s => Walk Transform s (ElementID s)
G.gId

gLabel :: (Element s, WalkType c, Lift Transform c) => Walk c s Text
gLabel :: forall s c.
(Element s, WalkType c, Lift Transform c) =>
Walk c s Text
gLabel = 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. Element s => Walk Transform s Text
G.gLabel

gValueMap :: (Element s, WalkType c, Lift Transform c) => Keys s -> Walk c s (PMap (ElementPropertyContainer s) GValue)
gValueMap :: forall s c.
(Element s, WalkType c, Lift Transform c) =>
Keys s -> Walk c s (PMap (ElementPropertyContainer s) GValue)
gValueMap Keys s
a = 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.
Element s =>
Keys s
-> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
G.gValueMap Keys s
a

gElementMap :: (Element s, WalkType c, Lift Transform c) => Keys s -> Walk c s (PMap Single GValue)
gElementMap :: forall s c.
(Element s, WalkType c, Lift Transform c) =>
Keys s -> Walk c s (PMap Single GValue)
gElementMap Keys s
a = 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.
Element s =>
Keys s -> Walk Transform s (PMap Single GValue)
G.gElementMap Keys s
a

gSelect1 :: (WalkType c, Lift Transform c) => AsLabel a -> Walk c s a
gSelect1 :: forall c a s.
(WalkType c, Lift Transform c) =>
AsLabel a -> Walk c s a
gSelect1 AsLabel a
a = 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 s. AsLabel a -> Walk Transform s a
G.gSelect1 AsLabel a
a

gSelectN :: (WalkType c, Lift Transform c) => AsLabel a -> AsLabel b -> [AsLabel c] -> Walk c s (SelectedMap GValue)
gSelectN :: forall c a b s.
(WalkType c, Lift Transform c) =>
AsLabel a
-> AsLabel b -> [AsLabel c] -> Walk c s (PMap Single GValue)
gSelectN AsLabel a
a AsLabel b
b [AsLabel c]
c = 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 c s.
AsLabel a
-> AsLabel b
-> [AsLabel c]
-> Walk Transform s (PMap Single GValue)
G.gSelectN AsLabel a
a AsLabel b
b [AsLabel c]
c

gSelectBy1 :: (WalkType c, Lift Transform c) => AsLabel a -> ByProjection a b -> Walk c s b
gSelectBy1 :: forall c a b s.
(WalkType c, Lift Transform c) =>
AsLabel a -> ByProjection a b -> Walk c s b
gSelectBy1 AsLabel a
a 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 s. AsLabel a -> ByProjection a b -> Walk Transform s b
G.gSelectBy1 AsLabel a
a ByProjection a b
b

gSelectByN :: (WalkType c, Lift Transform c) => AsLabel a -> AsLabel a -> [AsLabel a] -> ByProjection a b -> Walk c s (SelectedMap b)
gSelectByN :: forall c a b s.
(WalkType c, Lift Transform c) =>
AsLabel a
-> AsLabel a
-> [AsLabel a]
-> ByProjection a b
-> Walk c s (SelectedMap b)
gSelectByN AsLabel a
a AsLabel a
b [AsLabel a]
c ByProjection a b
d = 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 s.
AsLabel a
-> AsLabel a
-> [AsLabel a]
-> ByProjection a b
-> Walk Transform s (SelectedMap b)
G.gSelectByN AsLabel a
a AsLabel a
b [AsLabel a]
c ByProjection a b
d

gUnfold :: (AsIterator a, WalkType c, Lift Transform c) => Walk c a (IteratorItem a)
gUnfold :: forall a c.
(AsIterator a, WalkType c, Lift Transform c) =>
Walk c a (IteratorItem a)
gUnfold = 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. AsIterator a => Walk Transform a (IteratorItem a)
G.gUnfold

gPath :: (WalkType c, Lift Transform c) => Walk c s (Path GValue)
gPath :: forall c s.
(WalkType c, Lift Transform c) =>
Walk c s (Path GValue)
gPath = 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 Transform s (Path GValue)
G.gPath

gPathBy :: (WalkType c, Lift Transform c) => ByProjection a b -> [ByProjection a b] -> Walk c s (Path b)
gPathBy :: forall c a b s.
(WalkType c, Lift Transform c) =>
ByProjection a b -> [ByProjection a b] -> Walk c s (Path b)
gPathBy ByProjection a b
a [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 s.
ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b)
G.gPathBy ByProjection a b
a [ByProjection a b]
b

gFold :: (WalkType c, Lift Transform c) => Walk c a [a]
gFold :: forall c a. (WalkType c, Lift Transform c) => Walk c a [a]
gFold = 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. Walk Transform a [a]
G.gFold

gCount :: (WalkType c, Lift Transform c) => Walk c a Int
gCount :: forall c a. (WalkType c, Lift Transform c) => Walk c a Int
gCount = 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. Walk Transform a Int
G.gCount

gOut :: (Vertex v1, Vertex v2, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v1 v2
gOut :: forall v1 v2 c.
(Vertex v1, Vertex v2, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v1 v2
gOut [Greskell Text]
a = 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 v1 v2.
(Vertex v1, Vertex v2) =>
[Greskell Text] -> Walk Transform v1 v2
G.gOut [Greskell Text]
a

gOut' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AVertex
gOut' :: forall v c.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v AVertex
gOut' = forall v1 v2 c.
(Vertex v1, Vertex v2, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v1 v2
gOut

gOutE :: (Vertex v, Edge e, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v e
gOutE :: forall v e c.
(Vertex v, Edge e, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v e
gOutE [Greskell Text]
a = 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 v e.
(Vertex v, Edge e) =>
[Greskell Text] -> Walk Transform v e
G.gOutE [Greskell Text]
a

gOutE' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AEdge
gOutE' :: forall v c.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v AEdge
gOutE' = forall v e c.
(Vertex v, Edge e, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v e
gOutE

gOutV :: (Edge e, Vertex v, WalkType c, Lift Transform c) => Walk c e v
gOutV :: forall e v c.
(Edge e, Vertex v, WalkType c, Lift Transform c) =>
Walk c e v
gOutV = 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 e v. (Edge e, Vertex v) => Walk Transform e v
G.gOutV

gOutV' :: (Edge e, WalkType c, Lift Transform c) => Walk c e AVertex
gOutV' :: forall e c.
(Edge e, WalkType c, Lift Transform c) =>
Walk c e AVertex
gOutV' = forall e v c.
(Edge e, Vertex v, WalkType c, Lift Transform c) =>
Walk c e v
gOutV

gIn :: (Vertex v1, Vertex v2, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v1 v2
gIn :: forall v1 v2 c.
(Vertex v1, Vertex v2, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v1 v2
gIn [Greskell Text]
a = 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 v1 v2.
(Vertex v1, Vertex v2) =>
[Greskell Text] -> Walk Transform v1 v2
G.gIn [Greskell Text]
a

gIn' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AVertex
gIn' :: forall v c.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v AVertex
gIn' = forall v1 v2 c.
(Vertex v1, Vertex v2, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v1 v2
gIn

gInE :: (Vertex v, Edge e, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v e
gInE :: forall v e c.
(Vertex v, Edge e, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v e
gInE [Greskell Text]
a = 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 v e.
(Vertex v, Edge e) =>
[Greskell Text] -> Walk Transform v e
G.gInE [Greskell Text]
a

gInE' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AEdge
gInE' :: forall v c.
(Vertex v, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v AEdge
gInE' = forall v e c.
(Vertex v, Edge e, WalkType c, Lift Transform c) =>
[Greskell Text] -> Walk c v e
gInE

gInV :: (Edge e, Vertex v, WalkType c, Lift Transform c) => Walk c e v
gInV :: forall e v c.
(Edge e, Vertex v, WalkType c, Lift Transform c) =>
Walk c e v
gInV = 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 e v. (Edge e, Vertex v) => Walk Transform e v
G.gInV

gInV' :: (Edge e, WalkType c, Lift Transform c) => Walk c e AVertex
gInV' :: forall e c.
(Edge e, WalkType c, Lift Transform c) =>
Walk c e AVertex
gInV' = forall e v c.
(Edge e, Vertex v, WalkType c, Lift Transform c) =>
Walk c e v
gInV

gMatch :: (WalkType c, Lift Transform c) => Logic MatchPattern -> Walk c a MatchResult
gMatch :: forall c a.
(WalkType c, Lift Transform c) =>
Logic MatchPattern -> Walk c a MatchResult
gMatch Logic MatchPattern
a = 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. Logic MatchPattern -> Walk Transform a MatchResult
G.gMatch Logic MatchPattern
a

gAddV :: (Vertex v, WalkType c, Lift SideEffect c) => Greskell Text -> Walk c a v
gAddV :: forall v c a.
(Vertex v, WalkType c, Lift SideEffect c) =>
Greskell Text -> Walk c a v
gAddV Greskell Text
a = 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 v a. Vertex v => Greskell Text -> Walk SideEffect a v
G.gAddV Greskell Text
a

gAddV' :: (WalkType c, Lift SideEffect c) => Greskell Text -> Walk c a AVertex
gAddV' :: forall c a.
(WalkType c, Lift SideEffect c) =>
Greskell Text -> Walk c a AVertex
gAddV' = forall v c a.
(Vertex v, WalkType c, Lift SideEffect c) =>
Greskell Text -> Walk c a v
gAddV

gAddE :: (Vertex vs, Vertex ve, Edge e, WalkType c, Lift SideEffect c) => Greskell Text -> AddAnchor vs ve -> Walk c vs e
gAddE :: forall vs ve e c.
(Vertex vs, Vertex ve, Edge e, WalkType c, Lift SideEffect c) =>
Greskell Text -> AddAnchor vs ve -> Walk c vs e
gAddE Greskell Text
a AddAnchor vs ve
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 vs ve e.
(Vertex vs, Vertex ve, Edge e) =>
Greskell Text -> AddAnchor vs ve -> Walk SideEffect vs e
G.gAddE Greskell Text
a AddAnchor vs ve
b

gAddE' :: (WalkType c, Lift SideEffect c) => Greskell Text -> AddAnchor AVertex AVertex -> Walk c AVertex AEdge
gAddE' :: forall c.
(WalkType c, Lift SideEffect c) =>
Greskell Text -> AddAnchor AVertex AVertex -> Walk c AVertex AEdge
gAddE' = forall vs ve e c.
(Vertex vs, Vertex ve, Edge e, WalkType c, Lift SideEffect c) =>
Greskell Text -> AddAnchor vs ve -> Walk c vs e
gAddE

gFrom :: (ToGTraversal g, WalkType c, Lift c Transform) => g c s e -> AddAnchor s e
gFrom :: forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c, Lift c Transform) =>
g c s e -> AddAnchor s e
gFrom g c s e
a = forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
G.gFrom forall a b. (a -> b) -> a -> 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 g c s e
a

gTo :: (ToGTraversal g, WalkType c, Lift c Transform) => g c s e -> AddAnchor s e
gTo :: forall (g :: * -> * -> * -> *) c s e.
(ToGTraversal g, WalkType c, Lift c Transform) =>
g c s e -> AddAnchor s e
gTo g c s e
a = forall (g :: * -> * -> * -> *) s e.
ToGTraversal g =>
g Transform s e -> AddAnchor s e
G.gTo forall a b. (a -> b) -> a -> 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 g c s e
a

gDrop :: (Element e, WalkType c, Lift SideEffect c) => Walk c e e
gDrop :: forall e c.
(Element e, WalkType c, Lift SideEffect c) =>
Walk c e e
gDrop = 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 e. Element e => Walk SideEffect e e
G.gDrop

gDropP :: (Property p, WalkType c, Lift SideEffect c) => Walk c (p a) (p a)
gDropP :: forall (p :: * -> *) c a.
(Property p, WalkType c, Lift SideEffect c) =>
Walk c (p a) (p a)
gDropP = 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 (p :: * -> *) a. Property p => Walk SideEffect (p a) (p a)
G.gDropP

gProperty :: (Element e, WalkType c, Lift SideEffect c) => Key e v -> Greskell v -> Walk c e e
gProperty :: forall e c v.
(Element e, WalkType c, Lift SideEffect c) =>
Key e v -> Greskell v -> Walk c e e
gProperty Key e v
a Greskell v
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 e v.
Element e =>
Key e v -> Greskell v -> Walk SideEffect e e
G.gProperty Key e v
a Greskell v
b

gPropertyV :: (Vertex e, vp ~ ElementProperty e, Property vp, Element (vp v), WalkType c, Lift SideEffect c)
           => Maybe (Greskell Cardinality) -> Key e v -> Greskell v -> [KeyValue (vp v)] -> Walk c e e
gPropertyV :: forall e (vp :: * -> *) v c.
(Vertex e, vp ~ ElementProperty e, Property vp, Element (vp v),
 WalkType c, Lift SideEffect c) =>
Maybe (Greskell Cardinality)
-> Key e v -> Greskell v -> [KeyValue (vp v)] -> Walk c e e
gPropertyV Maybe (Greskell Cardinality)
a Key e v
b Greskell v
c [KeyValue (vp v)]
d = 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 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
G.gPropertyV Maybe (Greskell Cardinality)
a Key e v
b Greskell v
c [KeyValue (vp v)]
d