{-# 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
-- Description: Gremlin traversal/step types.
-- Maintainer: Toshio Ito <debug.ito@gmail.com>
--
-- This module defines 'GTraversal', greskell counterpart of
-- @GraphTraversal@ class object, and a DSL of composing graph
-- traversal steps.
module Data.Greskell.GTraversal
    ( -- * 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
      --
      -- | Functions for TinkerPop graph traversal steps.
      -- __For now greskell does not cover all graph traversal steps.__
      -- If you want some steps added, just open an issue.
      --
      -- There may be multiple versions of Haskell functions for a single step. This is because Gremlin
      -- steps are too polymorphic for Haskell. greskell should be type-safe so that incorrect combination
      -- of steps is detected in compile time.
      -- Functions for TinkerPop graph traversal steps.
    , unsafeWalk
    , modulateWith
      -- ** Filter steps
    , gIdentity
    , gIdentity'
    , gFilter
    , gCyclicPath
    , gCyclicPath'
    , gSimplePath
    , gSimplePath'
      -- ** Is step
    , gIs
    , gIs'
    , gIsP
    , gIsP'
      -- ** Has steps
    , gHas1
    , gHas1'
    , gHas2
    , gHas2'
    , gHas2P
    , gHas2P'
    , gHasLabel
    , gHasLabel'
    , gHasLabelP
    , gHasLabelP'
    , gHasId
    , gHasId'
    , gHasIdP
    , gHasIdP'
    , gHasKey
    , gHasKey'
    , gHasKeyP
    , gHasKeyP'
    , gHasValue
    , gHasValue'
    , gHasValueP
    , gHasValueP'
      -- ** Logic steps
    , gAnd
    , gOr
    , gNot
      -- ** Where step
    , gWhereP1
    , gWhereP1'
    , gWhereP2
    , 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
    , 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
    , gSideEffect'
      -- ** Graph manipulation steps
    , gAddV
    , gAddV'
    , gAddE
    , gAddE'
    , AddAnchor
    , gFrom
    , gTo
    , gDrop
    , gDropP
    , gProperty
    , gPropertyV
      -- ** @.by@ steps
      --
      -- | @.by@ steps are not 'Walk' on their own because they are always used in conjunction with
      -- other steps like 'gOrder'.
    , ByProjection (..)
    , ProjectionLike (..)
    , ByComparator (..)
    , LabeledByProjection (..)
    , gBy
    , gBy1
    , gBy2
    , gByL
      -- * Examples
    , examples
      -- * Only for tests
    , showWalkType
    , showLift
    , showSplit
    ) where

import           Control.Applicative      ((<$>), (<*>))
import           Control.Category         (Category, (>>>))
-- (below) to import Category methods without conflict with Prelude
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)

-- | @GraphTraversal@ class object of TinkerPop. It takes data @s@
-- from upstream and emits data @e@ to downstream. Type @c@ is called
-- \"walk type\", a marker to describe the effect of the traversal.
--
-- 'GTraversal' is NOT a 'Category'. Because a @GraphTraversal@ object
-- keeps some context data, the starting (left-most) @GraphTraversal@
-- object controls most of the behavior of entire composition of
-- traversals and steps. This violates 'Category' law.
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)

-- | Unsafely convert output type.
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

-- | Unsafely convert input and output types.
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

-- | Unwrap 'GTraversal' data constructor.
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

-- | Phantom type for @GraphTraversal@ class. In greskell, we usually
-- use 'GTraversal' instead of 'Greskell' 'GraphTraversal'.
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)

-- | 'GraphTraversal' is an Iterator.
instance AsIterator (GraphTraversal c s e) where
  type IteratorItem (GraphTraversal c s e) = e

-- | Unsafely convert output type.
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

-- | Unsafely convert input and output types.
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

-- | Types that can convert to 'GTraversal'.
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
  -- ^ Lift 'WalkType' @from@ to @to@. Use this for type matching.

  unsafeCastStart :: WalkType c => g c s1 e -> g c s2 e
  -- ^ Unsafely cast the start type @s1@ into @s2@.
  --
  -- It is recommended that @s2@ is coercible to @s1@ in terms of
  -- 'FromGraphSON'. That is, if @s2@ can parse a 'GValue', @s1@
  -- should also be able to parse that 'GValue'.
  --
  -- @since 1.0.0.0

  unsafeCastEnd :: WalkType c => g c s e1 -> g c s e2
  -- ^ Unsafely cast the end type @e1@ into @e2@. See
  -- 'unsafeCastStart'.
  --
  -- @since 1.0.0.0

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

-- | A chain of one or more Gremlin steps. Like 'GTraversal', type @s@
-- is the input, type @e@ is the output, and type @c@ is a marker to
-- describe the step.
--
-- 'Walk' represents a chain of method calls such as
-- @.has(x).outE()@. Because this is not a Gremlin (Groovy)
-- expression, we use bare 'Walk', not 'Greskell' 'Walk'.
--
-- 'Walk' is a 'Category'. You can use functions from
-- "Control.Category" to compose 'Walk's. This is equivalent to making
-- a chain of method calls in Gremlin.
--
-- 'Walk' is not an 'Eq', because it's difficult to define true
-- equality between Gremlin method calls. If we define it naively, it
-- might have conflict with 'Category' law.
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)

-- | 'id' is 'gIdentity'.
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)

-- | Based on 'Category'. 'Semigroup.<>' is 'Category.>>>'.
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.>>>)

-- | Based on 'Category' and 'Semigroup'. 'mempty' is 'Category.id'.
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.<>)

-- | Unsafely convert output type
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

-- | Unsafely convert input and output types.
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

-- | To convert a 'Walk' to 'GTraversal', it calls its static method
-- version on @__@ class.
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

-- | The 'Walk' is first converted to 'GTraversal', and it's converted
-- to 'Greskell'.
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 of phantom type markers to describe the effect of the
-- walk/traversals.
class WalkType t where
  -- | Only for tests.
  showWalkType :: Proxy t -> String

-- | WalkType for filtering steps.
--
-- A filtering step is a step that does filtering only. It takes input
-- and emits some of them without any modification, reordering,
-- traversal actions, or side-effects. Filtering decision must be
-- solely based on each element.
--
-- A 'Walk' @w@ is 'Filter' type iff:
--
-- > (gSideEffect w == gIdentity) AND (gFilter w == w)
--
-- If 'Walk's @w1@ and @w2@ are 'Filter' type, then
--
-- > gAnd [w1, w2] == w1 >>> w2 == w2 >>> w1
data Filter

instance WalkType Filter where
  showWalkType :: Proxy Filter -> String
showWalkType Proxy Filter
_ = String
"Filter"

-- | WalkType for steps without any side-effects. This includes
-- transformations, reordring, injections and graph traversal actions.
--
-- A 'Walk' @w@ is 'Transform' type iff:
--
-- > gSideEffect w == gIdentity
--
-- Obviously, every 'Filter' type 'Walk's are also 'Transform' type.
data Transform

instance WalkType Transform where
  showWalkType :: Proxy Transform -> String
showWalkType Proxy Transform
_ = String
"Transform"

-- | WalkType for steps that may have side-effects.
--
-- A side-effect here means manipulation of the \"sideEffect\" in
-- Gremlin context (i.e. the stash of data kept in a Traversal
-- object), as well as interaction with the world outside the
-- Traversal object.
--
-- For example, the following steps (in Gremlin) all have
-- side-effects.
--
-- > .addE('label')
-- > .aggregate('x')
-- > .sideEffect(System.out.&println)
-- > .map { some_variable += 1 }
data SideEffect

instance WalkType SideEffect where
  showWalkType :: Proxy SideEffect -> String
showWalkType Proxy SideEffect
_ = String
"SideEffect"

-- | Relation of 'WalkType's where one includes the other. @from@ can
-- be lifted to @to@, because @to@ is more powerful than @from@.
class Lift from to where
  -- | Only for tests.
  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

-- | Relation of 'WalkType's where the child walk @c@ is split from
-- the parent walk @p@.
--
-- When splitting, transformation effect done in the child walk is
-- rolled back (canceled) in the parent walk.
class Split c p where
  -- | Only for tests.
  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

-- | 'Transform' effect in the child walk is rolled back in the parent
-- walk.
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

-- | 'SideEffect' in the child walk remains in the parent walk.
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


-- | @GraphTraversalSource@ class object of TinkerPop. It is a factory
-- object of 'GraphTraversal's.
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)


-- | Create 'GraphTraversalSource' from a varible name in Gremlin
source :: Text -- ^ variable name of 'GraphTraversalSource'
       -> 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))

-- | @.V()@ method on 'GraphTraversalSource'.
sV :: Vertex v
   => [Greskell (ElementID v)] -- ^ vertex IDs
   -> 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

-- | Monomorphic version of 'sV'.
sV' :: [Greskell (ElementID AVertex)] -- ^ vertex IDs
    -> 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

-- | @.E()@ method on 'GraphTraversalSource'.
sE :: Edge e
   => [Greskell (ElementID e)] -- ^ edge IDs
   -> 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

-- | Monomorphic version of 'sE'.
sE' :: [Greskell (ElementID AEdge)] -- ^ edge IDs
    -> 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

-- | @.addV()@ method on 'GraphTraversalSource'.
--
-- @since 0.2.0.0
sAddV :: Vertex v
      => Greskell Text -- ^ vertex label
      -> 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

-- | Monomorphic version of 'sAddV'.
--
-- @since 0.2.0.0
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

-- | Unsafely create 'GTraversal' from the given raw Gremlin script.
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 &.

-- | Apply the 'Walk' to the 'GTraversal'. In Gremlin, this means
-- calling a chain of methods on the Traversal object.
(&.) :: 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 $.

-- | Same as '&.' with arguments flipped.
($.) :: 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 <$.>

-- | Similar to '<$>', but for '$.'.
--
-- @since 0.2.1.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 <*.>

-- | Similar to '<*>', but for '$.'.
--
-- @since 0.2.1.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

-- | @.iterate@ method on @GraphTraversal@.
--
-- 'gIterate' is not a 'Walk' because it's usually used to terminate
-- the method chain of Gremlin steps. The returned 'GTraversal'
-- outputs nothing, thus its end type is '()'.
--
-- @since 1.1.0.0
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

-- -- $walk-steps
-- --

methodCallText :: Text -- ^ method name
               -> [Text] -- ^ args
               -> 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

-- | Unsafely create a 'Walk' that represents a single method call on
-- a @GraphTraversal@.
unsafeWalk :: WalkType c
           => Text -- ^ step method name (e.g. "outE")
           -> [Text] -- ^ step method arguments
           -> 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

-- | Optionally modulate the main 'Walk' with some modulating 'Walk's.
modulateWith :: (WalkType c)
             => Walk c s e -- ^ the main 'Walk'
             -> [Walk c e e] -- ^ the modulating 'Walk's
             -> 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)

-- | @.identity@ step.
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'

-- | Monomorphic version of '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

-- | @.filter@ step that takes a traversal.
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]

-- | @.cyclicPath@ step.
--
-- @since 1.0.1.0
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'

-- | Monomorphic version of 'gCyclicPath'.
--
-- @since 1.0.1.0
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" []

-- | @.simplePath@ step.
--
-- @since 1.0.1.0
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'

-- | Monomorphic version of 'gSimplePath'.
--
-- @since 1.0.1.0
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

-- | @.where@ step with @P@ argument only.
--
-- If the 'ByProjection' argument is 'Nothing', comparison is
-- performed on the type @a@. You have to ensure that the comparator
-- included in the 'LabeledP' argument can handle the type
-- @a@. Usually this means the type @a@ should implement Java's
-- @Comparable@ interface (this is true for most Java classes).
--
-- If the 'ByProjection' argument is given, comparison is performed on
-- the projected values of type @b@. So, the type @b@ should implement
-- Java's @Comparable@ interface.
--
-- @since 1.2.0.0
gWhereP1 :: WalkType c
         => Greskell (LabeledP a) -- ^ the @P@ argument for @.where@ step.
         -> Maybe (ByProjection a b) -- ^ optional @.by@ modulation following the @.where@ step.
         -> 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

-- | Monomorphic version of 'gWhereP1'.
--
-- @since 1.2.0.0
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

-- | @.where@ step with the starting label and @P@ arguments. See also
-- 'gWhereP1'.
--
-- @since 1.2.0.0
gWhereP2 :: WalkType c
         => AsLabel a -- ^ the starting label of @.where@.
         -> Greskell (LabeledP a) -- ^ the @P@ argument for @.where@ step.
         -> Maybe (ByProjection a b) -- ^ optional @.by@ modulation following the @.where@ step.
         -> 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

-- | Monomorphic version of 'gWhereP2'.
--
-- @since 1.2.0.0
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

-- Developer note: the @.where@ step with a traversal argument is not
-- implemented yet, because @.match@ basically covers the same
-- capability. If we are to implement it, consider the following.
--
-- - The @.where@ step with a traversal argument doesn't take @.by@
--   modulation.
--
-- - The traversal argument is a logic tree (zero or more combination
--   of @__.and()@, @__.or()@ and @__.not()@ methods) of filtering
--   traversals.
--
-- - If a filtering traversal starts with @__.as()@ step,
--   it has a special meaning. The @__.as()@ step works just like
--   @__.select()@, fetching a value specified by the label from the
--   path history. In this case, the input value passed to the
--   @.where@ step is discarded.
--
-- - If a filtering traversal ends with @.as()@ step, it works like a
--   predicate step. If fetches a value specified by the label from
--   the path history, and checks if it's equal to the input
--   value. This behavior is like the one in @.match@ step, but
--   without variable binding.
--
-- - If a filtering traversal doesn't have @.as()@ step at the
--   beginning or end, it works just like it's in @.filter@ step.


-- | Result of @.match@ step.
--
-- @since 1.2.0.0
data MatchResult

-- | A pattern for @.match@ step.
--
-- @since 1.2.0.0
data MatchPattern where
  -- | A pattern with the starting @.as@ label followed by traversal steps.
  MatchPattern :: AsLabel a -> Walk Transform a b -> MatchPattern

-- | Make a 'GTraversal' from the 'MatchPattern'. This function is
-- unsafe because it discards the types of input and output
-- traversers.
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)

-- | A convenient function to make a 'MatchPattern' wrapped by
-- 'Logic.Leaf'.
--
-- @since 1.2.0.0
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)

-- | @.match@ step.
--
-- If the top-level 'Logic' of the argument is 'Logic.And', the
-- patterns are directly passed to the @.match@ step arguments.
--
-- The result of @.match@ step, 'MatchResult', is an opaque
-- type. Basically you should not use it. Instead, you should use
-- 'gSelectN' etc to access the path history labels inside the
-- 'MatchPattern'.
--
-- See also: https://groups.google.com/g/gremlin-users/c/HVtldzV0Xk8
--
-- @since 1.2.0.0
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

-- | @.is@ step of simple equality.
--
-- @since 1.0.1.0
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'

-- | Monomorphic version of 'gIs'.
--
-- @since 1.0.1.0
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]

-- | @.is@ step with predicate 'P'.
--
-- @since 1.0.1.0
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'

-- | Monomorphic version of 'gIsP'.
--
-- @since 1.0.1.0
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]

-- | @.has@ step with one argument.
gHas1 :: (WalkType c, Element s)
      => Key s v -- ^ property key
      -> 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'

-- | Monomorphic version of '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]

-- | @.has@ step with two arguments.
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

-- | Monomorphic verson of 'gHas2'.
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]

-- | @.has@ step with two arguments and 'P' type.
gHas2P :: (WalkType c, Element s)
       => Key s v -- ^ property key
       -> Greskell (P v) -- ^ predicate on the property value
       -> 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

-- | Monomorphic version of 'gHas2P'.
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]

-- TODO: has(Key,Traversal), has(Label,Key,P)

-- | @.hasLabel@ step.
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'

-- | Monomorphic version of '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]

-- | @.hasLabel@ step with 'P' type. Supported since TinkerPop 3.2.7.
gHasLabelP :: (Element s, WalkType c)
           => Greskell (P Text) -- ^ predicate on Element label.
           -> 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'

-- | Monomorphic version of '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]

-- | @.hasId@ step.
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'

-- | Monomorphic version of '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]

-- | @.hasId@ step with 'P' type. Supported since TinkerPop 3.2.7.
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'

-- | Monomorphic version of '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]

-- | @.hasKey@ step. The input type should be a VertexProperty.
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'

-- | Monomorphic version of '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]

-- | @.hasKey@ step with 'P' type. Supported since TinkerPop 3.2.7.
gHasKeyP :: (Element (p v), Property p, WalkType c)
         => Greskell (P Text) -- ^ predicate on the VertexProperty's key.
         -> 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'

-- | Monomorphic version of '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]

-- | @.hasValue@ step. The input type should be a VertexProperty.
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'

-- | Monomorphic version of '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]

-- | @.hasValue@ step with 'P' type. Supported since TinkerPop 3.2.7.
gHasValueP :: (Element (p v), Property p, WalkType c)
           => Greskell (P v) -- ^ predicate on the VertexProperty's value
           -> 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'

-- | Monomorphic version of '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 -- ^ method name
           -> [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

-- | @.and@ step.
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"

-- | @.or@ step.
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"

-- | @.not@ step.
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]

-- | @.range@ step. This step is not a 'Filter', because the filtering
-- decision by this step is based on position of each element, not the
-- element itself. This violates 'Filter' law.
gRange :: Greskell Int
       -- ^ min
       -> Greskell Int
       -- ^ max
       -> 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]

-- | @.limit@ step.
--
-- @since 0.2.1.0
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]

-- | @.tail@ step.
--
-- @since 0.2.1.0
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]

-- | @.skip@ step.
--
-- @since 0.2.1.0
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]

-- | A label that points to a loop created by @.repeat@ step. It can
-- be used by @.loops@ step to specify the loop.
--
-- @since 1.0.1.0
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)

-- | Return Gremlin String literal.
instance ToGreskell RepeatLabel where
  type GreskellReturn RepeatLabel = Text
  toGreskell :: RepeatLabel -> Greskell (GreskellReturn RepeatLabel)
toGreskell (RepeatLabel Text
t) = Text -> Greskell Text
Greskell.string Text
t

-- | Position of a step modulator relative to @.repeat@ step.
--
-- @since 1.0.1.0
data RepeatPos
  = RepeatHead -- ^ Modulator before the @.repeat@ step.
  | RepeatTail -- ^ Modulator after the @.repeat@ step.
  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)

-- | @.until@ or @.times@ modulator step.
--
-- Type @c@ is the 'WalkType' of the parent @.repeat@ step. Type @s@
-- is the start (and end) type of the @.repeat@ step.
--
-- @since 1.0.1.0
data RepeatUntil c s where
  -- | @.times@ modulator.
  RepeatTimes :: Greskell Int -> RepeatUntil c s
  -- | @.until@ modulator with a sub-traversal as the predicate to
  -- decide if the repetition should stop.
  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]

-- | @.emit@ modulator step.
--
-- Type @c@ is the 'WalkType' of the parent @.repeat@ step. Type @s@
-- is the start (and end) type of the @.repeat@ step.
--
-- @since 1.0.1.0
data RepeatEmit c s where
  -- | @.emit@ modulator without argument. It always emits the input
  -- traverser of type @s@.
  RepeatEmit :: RepeatEmit c s
  -- | @.emit@ modulator with a sub-traversal as the predicate to
  -- decide if it emits the traverser.
  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]



-- | Zero or more Gremlin steps.
--
-- @since 1.0.1.0
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

-- | @MWalk Nothing@ is coverted to identity step.
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



-- | @.repeat@ step.
--
-- @since 1.0.1.0
gRepeat :: (ToGTraversal g, WalkType c)
        => Maybe RepeatLabel -- ^ Label for the loop.
        -> Maybe (RepeatPos, RepeatUntil c s)
        -- ^ @.until@ or @.times@ modulator. You can use 'gTimes',
        -- 'gUntilHead', 'gUntilTail' to make this argument.
        -> Maybe (RepeatPos, RepeatEmit c s)
        -- ^ @.emit@ modulator. You can use 'gEmitHead', 'gEmitTail',
        -- 'gEmitHeadT', 'gEmitTailT' to make this argument.
        -> g c s s -- ^ Repeated traversal
        -> 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)

-- | @.times@ modulator before the @.repeat@ step. It always returns
-- 'Just'.
--
-- @since 1.0.1.0
gTimes :: Greskell Int
       -- ^ Repeat count. If it's less than or equal to 0, the
       -- repeated traversal is never executed.
       -> 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)

-- | @.until@ modulator before the @.repeat@ step. It always returns
-- 'Just'.
--
-- @since 1.0.1.0
gUntilHead :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
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)

-- | @.until@ modulator after the @.repeat@ step. It always returns
-- 'Just'.
--
-- @since 1.0.1.0
gUntilTail :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
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)

-- | @.emit@ modulator without argument before the @.repeat@ step. It
-- always returns 'Just'.
--
-- @since 1.0.1.0
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)

-- | @.emit@ modulator without argument after the @.repeat@ step. It
-- always returns 'Just'.
--
-- @since 1.0.1.0
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)

-- | @.emit@ modulator with a sub-traversal argument before the
-- @.repeat@ step. It always returns 'Just'.
--
-- @since 1.0.1.0
gEmitHeadT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
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)

-- | @.emit@ modulator with a sub-traversal argument after the
-- @.repeat@ step. It always returns 'Just'.
--
-- @since 1.0.1.0
gEmitTailT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
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)

-- | @.loops@ step.
--
-- @since 1.0.1.0
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

-- | @.local@ step.
--
-- @since 1.0.1.0
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]

-- | @.union@ step.
--
-- @since 1.0.1.0
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

-- | @.coalesce@ step.
--
-- Like 'gFlatMap', 'gCoalesce' always modifies path history.
--
-- @since 1.1.0.0
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

-- | @.choose@ step with if-then-else style.
--
-- @since 1.0.1.0
gChoose3 :: (ToGTraversal g, Split cc c, WalkType cc, WalkType c)
         => g cc s ep -- ^ the predicate traversal.
         -> g c s e -- ^ The traversal executed if the predicate traversal outputs something.
         -> g c s e -- ^ The traversal executed if the predicate traversal outputs nothing.
         -> Walk c s e
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
                    ]

-- | @.barrier@ step.
--
-- @since 1.0.1.0
gBarrier :: WalkType c
         => Maybe (Greskell Int)
         -- ^ Max number of traversers kept at this barrier.
         -> 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

-- | @.dedup@ step without argument.
--
-- @.dedup@ step is 'Transform' because the filtering decision depends
-- on the sequence (order) of input elements.
--
-- @since 1.0.1.0
gDedup :: Maybe (ByProjection s e)
       -- ^ @.by@ modulator. If specified, the result of type @e@ is
       -- used as the criterion of deduplication.
       -> 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

-- | @.dedup@ step with at least one argument. The tuple specified by
-- the 'AsLabel's is used as the criterion of deduplication.
--
-- @since 1.0.1.0
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


-- | Data types that mean a projection from one type to another.
class ProjectionLike p where
  type ProjectionLikeStart p
  -- ^ The start type of the projection.
  type ProjectionLikeEnd p
  -- ^ The end type of the projection.

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


-- | Projection from type @s@ to type @e@ used in @.by@ step. You can
-- also use 'gBy' to construct 'ByProjection'.
data ByProjection s e where
  ByProjection :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)

-- | Projection by literal property key.
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

-- | @.by@ step with 1 argument, used for projection.
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

-- | Comparison of type @s@ used in @.by@ step. You can also use
-- 'gBy1' and 'gBy2' to construct 'ByComparator'.
data ByComparator s where
  -- | Type @s@ is projected to type @e@, and compared by the natural
  -- comparator of type @e@.
  ByComparatorProj :: ByProjection s e -> ByComparator s
  -- | Type @s@ is compared by the 'Comparator' @comp@.
  ByComparatorComp :: Comparator comp => Greskell comp -> ByComparator (CompareArg comp)
  -- | Type @s@ is projected to type @CompareArg comp@, and compared
  -- by the 'Comparator' @comp@.
  ByComparatorProjComp :: Comparator comp => ByProjection s (CompareArg comp) -> Greskell comp -> ByComparator s

-- | 'ByComparatorProj' by literal property key.
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

-- | @.by@ step with 1 argument, used for comparison.
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

-- | @.by@ step with 2 arguments, used for comparison.
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

-- | @.order@ step.
--
-- 'ByComparator' is an 'IsString', meaning projection by the given
-- key.
gOrder :: [ByComparator s] -- ^ following @.by@ steps.
       -> 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]

-- | A 'ByProjection' associated with an 'AsLabel'. You can construct
-- it by 'gByL'.
--
-- @since 1.0.0.0
data LabeledByProjection s where
  LabeledByProjection :: AsLabel a -> ByProjection s a -> LabeledByProjection s

-- | @.by@ step associated with an 'AsLabel'.
--
-- @since 1.0.0.0
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

-- | @.flatMap@ step.
--
-- @.flatMap@ step is at least as powerful as 'Transform', even if the
-- child walk is 'Filter' type. This is because @.flatMap@ step always
-- modifies the path of the Traverser.
--
-- @since 1.1.0.0
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]

-- | Monomorphic version of 'gFlatMap'.
--
-- @since 1.1.0.0
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

-- | @.V@ step.
--
-- For each input item, @.V@ step emits vertices selected by the
-- argument (or all vertices if the empty list is passed.)
--
-- @since 0.2.0.0
gV :: 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

-- | Monomorphic version of 'gV'.
--
-- @since 0.2.0.0
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

-- | @.constant@ step.
--
-- @since 1.0.1.0
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]

-- | @.unfold@ step.
--
-- Note that we use 'AsIterator' here because basically the @.unfold@
-- step does the same thing as @IteratorUtils.asIterator@ function in
-- Tinkerpop. However, Tinkerpop's implementation of @.unfold@ step
-- doesn't necessarily use @asIterator@, so there may be some corner
-- cases where @asIterator@ and @.unfold@ step behave differently.
--
-- @since 1.0.1.0
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" []

-- | @.as@ step.
--
-- @.as@ step is 'Transform' because it adds the label to the
-- traverser.
--
-- @since 0.2.2.0
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]

-- | @.values@ step.
--
gValues :: Element s
        => [Key s e]
        -- ^ property keys
        -> 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

-- | @.properties@ step.
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

-- | @.id@ step.
--
-- @since 0.2.1.0
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" []

-- | @.label@ step.
--
-- @since 0.2.1.0
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" []

-- | @.valueMap@ step.
--
-- @since 1.0.0.0
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

-- | @.elementMap@ step.
--
-- @since 2.0.1.0
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

-- | @.select@ step with one argument.
--
-- @since 0.2.2.0
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]

-- | @.select@ step with more than one arguments.
--
-- @since 0.2.2.0
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]

-- | @.select@ step with one argument followed by @.by@ step.
--
-- @since 0.2.2.0
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]

-- | @.select@ step with more than one arguments followed by @.by@
-- step.
--
-- @since 0.2.2.0
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]

-- | @.project@ step.
--
-- @since 1.0.0.0
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]

-- | @.path@ step without modulation.
--
-- @since 1.1.0.0
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" []

-- | @.path@ step with one or more @.by@ modulations.
--
-- @since 1.1.0.0
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

-- | @.fold@ step.
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" []

-- | @.count@ step.
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

-- | @.out@ step
gOut :: (Vertex v1, Vertex v2)
     => [Greskell Text] -- ^ edge labels
     -> 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"

-- | Monomorphic version of 'gOut'.
gOut' :: (Vertex v)
      => [Greskell Text] -- ^ edge labels
      -> 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

-- | @.outE@ step
gOutE :: (Vertex v, Edge e)
      => [Greskell Text] -- ^ edge labels
      -> 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"

-- | Monomorphic version of 'gOutE'.
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

-- | @.outV@ step.
--
-- @since 0.2.2.0
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" []

-- | Monomorphic version of 'gOutV'.
--
-- @since 0.2.2.0
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

-- | @.in@ step
gIn :: (Vertex v1, Vertex v2)
    => [Greskell Text] -- ^ edge labels
    -> 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"

-- | Monomorphic version of 'gIn'.
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

-- | @.inE@ step.
gInE :: (Vertex v, Edge e)
     => [Greskell Text] -- ^ edge labels
     -> 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"

-- | Monomorphic version of 'gInE'.
gInE' :: (Vertex v)
      => [Greskell Text] -- ^ edge labels
      -> 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

-- | @.inV@ step.
--
-- @since 0.2.2.0
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" []

-- | Monomorphic version of 'gInV'.
--
-- @since 0.2.2.0
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

-- | @.sideEffect@ step that takes a traversal.
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]

-- | Monomorphic version of 'gSideEffect'. The result walk is always
-- 'SideEffect' type.
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

-- | @.addV@ step with a label.
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]

-- | Monomorphic version of 'gAddV'.
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

-- | @.drop@ step on 'Element'.
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" []

-- | @.drop@ step on 'Property'.
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" []

-- | Simple @.property@ step. It adds a value to the property.
--
-- @since 0.2.0.0
gProperty :: Element e
          => Key e v -- ^ key of the property
          -> Greskell v -- ^ value of the property
          -> 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]

-- | @.property@ step for 'Vertex'.
--
-- @since 0.2.0.0
gPropertyV :: (Vertex e, vp ~ ElementProperty e, Property vp, Element (vp v))
           => Maybe (Greskell Cardinality) -- ^ optional cardinality of the vertex property.
           -> Key e v -- ^ key of the vertex property
           -> Greskell v -- ^ value of the vertex property
           -> [KeyValue (vp v)] -- ^ optional meta-properties for the vertex property.
           -> Walk SideEffect e e
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
_)               = []

-- | Vertex anchor for 'gAddE'. It corresponds to @.from@ or @.to@
-- step following an @.addE@ step.
--
-- Type @s@ is the input Vertex for the @.addE@ step. Type @e@ is the
-- type of the anchor Vertex that the 'AddAnchor' yields. So, @.addE@
-- step creates an edge between @s@ and @e@.
--
-- @since 0.2.0.0
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]

-- | @.from@ step with a traversal.
--
-- @since 0.2.0.0
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

-- | @.to@ step with a traversal.
--
-- @since 0.2.0.0
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

-- | @.addE@ step. Supported since TinkerPop 3.1.0.
--
-- @since 0.2.0.0
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

-- | Monomorphic version of 'gAddE'.
--
-- @since 0.2.0.0
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 of using this module. See the source. The 'fst' of the output is the testee, while the
-- 'snd' is the expectation.
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())"
    )
  ]