-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Haskell binding for Gremlin graph query language
--
-- Haskell binding for Gremlin graph query language. See
-- README.md for detail.
--
-- This package is the main entry point of greskell family. It re-exports
-- greskell-core package, and adds some useful functions to it.
@package greskell
@version 1.2.0.1
-- | This modules defines types and functions for utility classes in
-- Gremlin.
module Data.Greskell.Gremlin
-- | java.util.function.Predicate interface.
--
-- A Predicate p is a function that takes
-- PredicateArg p and returns Bool.
class Predicate p where {
type family PredicateArg p;
}
-- | .and method.
pAnd :: Predicate p => Greskell p -> Greskell p -> Greskell p
-- | .or method.
pOr :: Predicate p => Greskell p -> Greskell p -> Greskell p
-- | .test method.
pTest :: Predicate p => Greskell p -> Greskell (PredicateArg p) -> Greskell Bool
-- | .nagate method.
pNegate :: Predicate p => Greskell p -> Greskell p
-- | Type for anonymous class of Predicate interface.
newtype PredicateA a
PredicateA :: (a -> Bool) -> PredicateA a
[unPredicateA] :: PredicateA a -> a -> Bool
-- | org.apache.tinkerpop.gremlin.process.traversal.P class.
--
-- P a keeps data of type a and compares it with data
-- of type a given as the Predicate argument.
data P a
-- | Type that is compatible with P. You can construct a value of
-- type Greskell p using values of PParameter p.
--
-- Note that the type of constuctor arguments (i.e. GreskellReturn
-- (PParameter p)) should implement Java's Comparable
-- interface. This is true for most types, so greskell doesn't have any
-- explicit constraint about it.
class (ToGreskell (PParameter p)) => PLike p where {
type family PParameter p;
}
-- | P.not static method.
--
--
-- >>> toGremlin (pNot $ pEq $ 10 :: Greskell (P Int))
-- "P.not(P.eq(10))"
--
pNot :: PLike p => Greskell p -> Greskell p
-- | P.eq static method.
--
--
-- >>> toGremlin (pEq $ string "hoge" :: Greskell (P Text))
-- "P.eq(\"hoge\")"
--
pEq :: PLike p => PParameter p -> Greskell p
-- | P.neq static method.
pNeq :: PLike p => PParameter p -> Greskell p
-- | P.lt static method.
pLt :: PLike p => PParameter p -> Greskell p
-- | P.lte static method.
pLte :: PLike p => PParameter p -> Greskell p
-- | P.gt static method.
pGt :: PLike p => PParameter p -> Greskell p
-- | P.gte static method.
pGte :: PLike p => PParameter p -> Greskell p
-- | P.inside static method.
--
--
-- >>> toGremlin (pInside 10 20 :: Greskell (P Int))
-- "P.inside(10,20)"
--
pInside :: PLike p => PParameter p -> PParameter p -> Greskell p
-- | P.outside static method.
pOutside :: PLike p => PParameter p -> PParameter p -> Greskell p
-- | P.between static method.
pBetween :: PLike p => PParameter p -> PParameter p -> Greskell p
-- | P.within static method.
--
--
-- >>> toGremlin (pWithin ["foo", "bar", "hoge"] :: Greskell (P Text))
-- "P.within(\"foo\",\"bar\",\"hoge\")"
--
pWithin :: PLike p => [PParameter p] -> Greskell p
-- | P.without static method.
pWithout :: PLike p => [PParameter p] -> Greskell p
-- | java.util.Comparator interface.
--
-- Comparator compares two data of type CompareArg
-- c.
class Comparator c where {
type family CompareArg c;
}
-- | .compare method.
cCompare :: Comparator c => Greskell c -> Greskell (CompareArg c) -> Greskell (CompareArg c) -> Greskell Int
-- | .reversed method.
cReversed :: Comparator c => Greskell c -> Greskell c
-- | .thenComparing method.
cThenComparing :: Comparator c => Greskell c -> Greskell c -> Greskell c
-- | Type for anonymous class of Comparator interface.
newtype ComparatorA a
ComparatorA :: (a -> a -> Int) -> ComparatorA a
[unComparatorA] :: ComparatorA a -> a -> a -> Int
-- | org.apache.tinkerpop.gremlin.process.traversal.Order enum.
data Order a
-- | decr order.
--
--
-- >>> toGremlin oDecr
-- "Order.decr"
--
oDecr :: Greskell (Order a)
-- | incr order.
oIncr :: Greskell (Order a)
-- | shuffle order.
oShuffle :: Greskell (Order a)
instance Data.Greskell.Gremlin.Comparator (Data.Greskell.Gremlin.Order a)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.Gremlin.Order a)
instance Data.Greskell.Gremlin.Comparator (Data.Greskell.Gremlin.ComparatorA a)
instance Data.Greskell.Gremlin.PLike (Data.Greskell.Gremlin.P a)
instance Data.Greskell.Gremlin.Predicate (Data.Greskell.Gremlin.P a)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.Gremlin.P a)
instance Data.Greskell.Gremlin.Predicate (Data.Greskell.Gremlin.PredicateA a)
-- | Developer note: This module defines Logic, a data structure for
-- logic operation tree. There are already similar packages to this
-- module, but, none of them satisfy our requirements.
--
-- Boolean/logic tree data structures
--
--
--
-- Typeclasses about boolean/logic operations
--
--
--
-- Trees that contain heterogeneous values
--
--
module Data.Greskell.Logic
-- | A general-purpose logic tree structure. Only the leaf nodes have
-- values of type a. The tree is lazy both in value and spine
-- (structure).
data Logic a
-- | Leaf node with value
Leaf :: a -> Logic a
-- | "and" logic operator
And :: Logic a -> [Logic a] -> Logic a
-- | "or" logic operator
Or :: Logic a -> [Logic a] -> Logic a
-- | "not" logic operator
Not :: Logic a -> Logic a
-- | Run the logic tree of Bool values to get the result.
runBool :: Logic Bool -> Bool
instance GHC.Generics.Generic (Data.Greskell.Logic.Logic a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Greskell.Logic.Logic a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Greskell.Logic.Logic a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Greskell.Logic.Logic a)
instance GHC.Base.Functor Data.Greskell.Logic.Logic
instance GHC.Base.Applicative Data.Greskell.Logic.Logic
instance GHC.Base.Monad Data.Greskell.Logic.Logic
instance Data.Foldable.Foldable Data.Greskell.Logic.Logic
instance Data.Traversable.Traversable Data.Greskell.Logic.Logic
module Data.Greskell.NonEmptyLike
-- | Non-empty containers. Its cardinality is one or more.
class Foldable t => NonEmptyLike t
-- | Make a container with a single value.
singleton :: NonEmptyLike t => a -> t a
-- | Append two containers.
append :: NonEmptyLike t => t a -> t a -> t a
-- | Convert the container to NonEmpty list.
toNonEmpty :: NonEmptyLike t => t a -> NonEmpty a
instance Data.Greskell.NonEmptyLike.NonEmptyLike GHC.Base.NonEmpty
instance Data.Greskell.NonEmptyLike.NonEmptyLike Data.Semigroup.First
instance Data.Greskell.NonEmptyLike.NonEmptyLike Data.Semigroup.Last
-- | This module defines PMap, a map with Text keys and
-- cardinality options.
module Data.Greskell.PMap
-- | A property map, which has text keys and v values. c
-- specifies the cardinality of each item, and should be an instance of
-- NonEmptyLike.
--
-- You can look up values from PMap using key types of
-- PMapKey class.
data PMap c v
-- | Lookup the first value for the key from PMap.
lookup :: (PMapKey k, NonEmptyLike c) => k -> PMap c v -> Maybe v
-- | MonadThrow version of lookup. If there is no value for
-- the key, it throws PMapNoSuchKey.
lookupM :: (PMapKey k, NonEmptyLike c, MonadThrow m) => k -> PMap c v -> m v
-- | Lookup the value and parse it into a.
lookupAs :: (PMapKey k, NonEmptyLike c, PMapValue k ~ a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException a
-- | Similar to lookupAs, but this function converts a null
-- result into Nothing.
--
-- A null result is either (1) the key k is not found
-- in the map, or (2) the key is found, but the value is null.
lookupAs' :: (PMapKey k, NonEmptyLike c, PMapValue k ~ Maybe a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException (Maybe a)
-- | MonadThrow version of lookupAs.
lookupAsM :: (PMapKey k, NonEmptyLike c, PMapValue k ~ a, FromGraphSON a, MonadThrow m) => k -> PMap c GValue -> m a
-- | Lookup all items for the key. If there is no item for the key, it
-- returns an empty list.
lookupList :: (PMapKey k, NonEmptyLike c) => k -> PMap c v -> [v]
-- | Look up the values and parse them into a.
lookupListAs :: (PMapKey k, NonEmptyLike c, PMapValue k ~ a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException (NonEmpty a)
-- | Similar to lookupListAs, but this function accepts
-- null results.
--
-- If the key k is not found in the map, it returns an empty
-- list. If the key k is found and nulls are included
-- in the values, they are obtained as Nothing.
lookupListAs' :: (PMapKey k, NonEmptyLike c, PMapValue k ~ Maybe a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException [Maybe a]
-- | Insert a key-value pair to PMap. If it already has some items
-- for that key, append method of the NonEmptyLike type
-- c determines its behavior.
pMapInsert :: NonEmptyLike c => Text -> v -> PMap c v -> PMap c v
-- | Delete a key and all values associated with it.
pMapDelete :: Text -> PMap c v -> PMap c v
-- | Lookup all items for the key (low-level function). If there is no item
-- for the key, it returns an empty list.
pMapLookup :: NonEmptyLike c => Text -> PMap c v -> [v]
-- | List up all entries.
pMapToList :: Foldable c => PMap c v -> [(Text, v)]
-- | Make a PMap from list of entries.
pMapFromList :: NonEmptyLike c => [(Text, v)] -> PMap c v
-- | The single cardinality for PMap. pMapInsert method
-- replaces the old value. <> on PMap prefers the
-- items from the left PMap. pMapFromList prefers the first
-- item for each key.
type Single = First
-- | The "one or more" cardinality for PMap. pMapInsert
-- method prepends the new value at the head. <> on
-- PMap appends the right items to the tail of the left items.
-- pMapFromList preserves the order of the items for each key.
data Multi a
-- | A typed key for PMap.
class PMapKey k where {
-- | Type of the value associated with the key.
type family PMapValue k :: *;
}
-- | Text representation of the key.
keyText :: PMapKey k => k -> Text
-- | An Exception raised when looking up values from PMap.
data PMapLookupException
-- | The PMap doesn't have the given key.
PMapNoSuchKey :: Text -> PMapLookupException
-- | Failed to parse the value into the type that the PMapKey
-- indicates. The Text is the key, and the String is the
-- error message.
PMapParseError :: Text -> String -> PMapLookupException
-- | Make a human-readable description on PMapLookupException.
pMapDecribeError :: PMapLookupException -> String
-- | Convert the lookup result into a MonadThrow. It throws
-- PMapLookupException.
pMapToThrow :: MonadThrow m => Either PMapLookupException a -> m a
-- | Convert the lookup result into a MonadFail. It fails with the
-- description returned by pMapDecribeError.
pMapToFail :: MonadFail m => Either PMapLookupException a -> m a
instance Data.Traversable.Traversable c => Data.Traversable.Traversable (Data.Greskell.PMap.PMap c)
instance Data.Foldable.Foldable c => Data.Foldable.Foldable (Data.Greskell.PMap.PMap c)
instance GHC.Base.Functor c => GHC.Base.Functor (Data.Greskell.PMap.PMap c)
instance GHC.Classes.Eq (c v) => GHC.Classes.Eq (Data.Greskell.PMap.PMap c v)
instance GHC.Show.Show (c v) => GHC.Show.Show (Data.Greskell.PMap.PMap c v)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.PMap.Multi a)
instance Data.Greskell.NonEmptyLike.NonEmptyLike Data.Greskell.PMap.Multi
instance Data.Traversable.Traversable Data.Greskell.PMap.Multi
instance Data.Foldable.Foldable Data.Greskell.PMap.Multi
instance GHC.Base.Semigroup (Data.Greskell.PMap.Multi a)
instance GHC.Base.Functor Data.Greskell.PMap.Multi
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Greskell.PMap.Multi a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Greskell.PMap.Multi a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Greskell.PMap.Multi a)
instance GHC.Classes.Ord Data.Greskell.PMap.PMapLookupException
instance GHC.Classes.Eq Data.Greskell.PMap.PMapLookupException
instance GHC.Show.Show Data.Greskell.PMap.PMapLookupException
instance GHC.Exception.Type.Exception Data.Greskell.PMap.PMapLookupException
instance Data.Greskell.PMap.PMapKey Data.Text.Internal.Text
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.PMap.PMap c v)
instance Data.Greskell.GraphSON.FromGraphSON (c v) => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.PMap.PMap c v)
instance Data.Greskell.NonEmptyLike.NonEmptyLike c => GHC.Base.Semigroup (Data.Greskell.PMap.PMap c v)
instance Data.Greskell.NonEmptyLike.NonEmptyLike c => GHC.Base.Monoid (Data.Greskell.PMap.PMap c v)
instance Data.Greskell.AsIterator.AsIterator (Data.Greskell.PMap.PMap c v)
module Data.Greskell.AsLabel
-- | AsLabel a represents a label string used in
-- .as step pointing to the data of type a.
newtype AsLabel a
AsLabel :: Text -> AsLabel a
[unAsLabel] :: AsLabel a -> Text
-- | A map keyed with AsLabel. Obtained from .select step,
-- for example.
type SelectedMap = PMap Single
-- | Unsafely cast the phantom type of the AsLabel.
unsafeCastAsLabel :: AsLabel a -> AsLabel b
-- | Lookup the first value for the key from PMap.
lookup :: (PMapKey k, NonEmptyLike c) => k -> PMap c v -> Maybe v
-- | MonadThrow version of lookup. If there is no value for
-- the key, it throws PMapNoSuchKey.
lookupM :: (PMapKey k, NonEmptyLike c, MonadThrow m) => k -> PMap c v -> m v
-- | Lookup the value and parse it into a.
lookupAs :: (PMapKey k, NonEmptyLike c, PMapValue k ~ a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException a
-- | MonadThrow version of lookupAs.
lookupAsM :: (PMapKey k, NonEmptyLike c, PMapValue k ~ a, FromGraphSON a, MonadThrow m) => k -> PMap c GValue -> m a
-- | An Exception raised when looking up values from PMap.
data PMapLookupException
-- | The PMap doesn't have the given key.
PMapNoSuchKey :: Text -> PMapLookupException
-- | Failed to parse the value into the type that the PMapKey
-- indicates. The Text is the key, and the String is the
-- error message.
PMapParseError :: Text -> String -> PMapLookupException
-- | LabeledP is just like P, a Haskell representation of
-- TinkerPop's P class. Unlike P, however,
-- LabeledP keeps a label (AsLabel) inside. It is used in
-- .where step.
data LabeledP a
instance Data.Hashable.Class.Hashable (Data.Greskell.AsLabel.AsLabel a)
instance GHC.Classes.Ord (Data.Greskell.AsLabel.AsLabel a)
instance GHC.Classes.Eq (Data.Greskell.AsLabel.AsLabel a)
instance GHC.Show.Show (Data.Greskell.AsLabel.AsLabel a)
instance Data.Greskell.Gremlin.PLike (Data.Greskell.AsLabel.LabeledP a)
instance Data.String.IsString (Data.Greskell.AsLabel.AsLabel a)
instance Data.Greskell.Greskell.ToGreskell (Data.Greskell.AsLabel.AsLabel a)
instance GHC.Base.Functor Data.Greskell.AsLabel.AsLabel
instance Data.Greskell.PMap.PMapKey (Data.Greskell.AsLabel.AsLabel a)
-- | This module defines types and functions about TinkerPop graph
-- structure API.
module Data.Greskell.Graph
-- | org.apache.tinkerpop.gremlin.structure.Element interface in a
-- TinkerPop graph.
--
-- Since greskell-1.0.0.0, ElementData is a super-class of
-- Element.
class ElementData e => Element e where {
-- | Property type of the Element. It should be of Property
-- class.
type family ElementProperty e :: * -> *;
-- | Container type of the properties of the Element. It should be
-- of NonEmptyLike class.
type family ElementPropertyContainer e :: * -> *;
}
-- | Types that keep reference to TinkerPop graph Elements.
class ElementData e
-- | ID of this Element.
elementId :: ElementData e => e -> ElementID e
-- | Label of this Element.
elementLabel :: ElementData e => e -> Text
-- | ID of a graph element e (vertex, edge and vertex property).
newtype ElementID e
ElementID :: GValue -> ElementID e
-- | Although it's exposed, it is recommended NOT to rely on the internal
-- of ElementID. That's because it depends on graph
-- implementation.
[unElementID] :: ElementID e -> GValue
-- | Unsafely cast the phantom type of ElementID.
unsafeCastElementID :: ElementID a -> ElementID b
-- | org.apache.tinkerpop.gremlin.structure.Vertex interface in a
-- TinkerPop graph.
class (Element v) => Vertex v
-- | org.apache.tinkerpop.gremlin.structure.Edge interface in a
-- TinkerPop graph.
class (Element e) => Edge e
-- | org.apache.tinkerpop.gremlin.structure.Property interface in
-- a TinkerPop graph.
class Property p
-- | Get key of this property.
propertyKey :: Property p => p v -> Text
-- | Get value of this property.
propertyValue :: Property p => p v -> v
-- | org.apache.tinkerpop.gremlin.structure.T enum.
--
-- T is a token to get data b from an Element a.
data T a b
-- | T.id token.
tId :: Element a => Greskell (T a (ElementID a))
-- | T.key token.
tKey :: (Element (p v), Property p) => Greskell (T (p v) Text)
-- | T.label token.
tLabel :: Element a => Greskell (T a Text)
-- | T.value token.
tValue :: (Element (p v), Property p) => Greskell (T (p v) v)
-- |
-- org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality
-- enum.
data Cardinality
-- | list Cardinality.
--
--
-- >>> toGremlin cList
-- "list"
--
cList :: Greskell Cardinality
-- | set Cardinality.
cSet :: Greskell Cardinality
-- | single Cardinality.
cSingle :: Greskell Cardinality
-- | A property key accessing value b in an Element a. In
-- Gremlin, it's just a String type.
--
--
-- >>> toGremlin ("age" :: Key AVertex Int)
-- "\"age\""
--
-- >>> toGremlin (key "created_at" :: Key AEdge Text)
-- "\"created_at\""
--
-- >>> keyText ("name" :: Key AVertex Text)
-- "name"
--
--
-- Since greskell-1.0.0.0, Key is newtype of Text. Before
-- that, it was newtype of Greskell Text.
newtype Key a b
Key :: Text -> Key a b
[unKey] :: Key a b -> Text
-- | Create a Key a text.
key :: Text -> Key a b
-- | Unsafely cast the type signature of the Key.
unsafeCastKey :: Key a1 b1 -> Key a2 b2
-- | Pair of Key and its value. Mainly used for writing properties
-- into the database.
--
-- Type a is the type of Element that keeps the
-- KeyValue pair. It drops the type of the value, so that you can
-- construct a heterogeneous list of key-value pairs for a given
-- Element.
data KeyValue a
-- | Key and value
[KeyValue] :: Key a b -> Greskell b -> KeyValue a
-- | Key without value
[KeyNoValue] :: Key a b -> KeyValue a
-- | Constructor operator of KeyValue.
(=:) :: Key a b -> Greskell b -> KeyValue a
-- | Heterogeneous list of Keys. It keeps the parent type
-- a, but discards the value type b.
data Keys a
-- | Empty Keys.
[KeysNil] :: Keys a
-- | Add a Key to Keys.
[KeysCons] :: Key a b -> Keys a -> Keys a
-- | Keys with a single Key.
singletonKeys :: Key a b -> Keys a
-- | Prepend a Key to Keys.
(-:) :: Key a b -> Keys a -> Keys a
infixr 5 -:
-- | org.apache.tinkerpop.gremlin.process.traversal.Path
-- interface.
newtype Path a
Path :: [PathEntry a] -> Path a
[unPath] :: Path a -> [PathEntry a]
-- | An entry in a Path.
data PathEntry a
PathEntry :: HashSet (AsLabel a) -> a -> PathEntry a
[peLabels] :: PathEntry a -> HashSet (AsLabel a)
[peObject] :: PathEntry a -> a
-- | Convert a Path into PMap.
--
-- In the result PMap, the keys are the labels in the Path,
-- and the values are the objects associated with the labels. The values
-- are stored in the same order in the Path. Objects without any
-- label are discarded.
pathToPMap :: Path a -> PMap Multi a
-- | Make a PathEntry.
makePathEntry :: [AsLabel a] -> a -> PathEntry a
-- | General vertex type you can use for Vertex class.
data AVertex
AVertex :: ElementID AVertex -> Text -> AVertex
-- | ID of this vertex
[avId] :: AVertex -> ElementID AVertex
-- | Label of this vertex
[avLabel] :: AVertex -> Text
-- | General edge type you can use for Edge class.
data AEdge
AEdge :: ElementID AEdge -> Text -> AEdge
-- | ID of this edge.
[aeId] :: AEdge -> ElementID AEdge
-- | Label of this edge.
[aeLabel] :: AEdge -> Text
-- | General vertex property type you can use for VertexProperty.
--
-- If you are not sure about the type v, just use GValue.
data AVertexProperty v
AVertexProperty :: ElementID (AVertexProperty v) -> Text -> v -> AVertexProperty v
-- | ID of this vertex property.
[avpId] :: AVertexProperty v -> ElementID (AVertexProperty v)
-- | Label and key of this vertex property.
[avpLabel] :: AVertexProperty v -> Text
-- | Value of this vertex property.
[avpValue] :: AVertexProperty v -> v
-- | General simple property type you can use for Property class.
--
-- If you are not sure about the type v, just use GValue.
data AProperty v
AProperty :: Text -> v -> AProperty v
[apKey] :: AProperty v -> Text
[apValue] :: AProperty v -> v
instance Data.Hashable.Class.Hashable (Data.Greskell.Graph.ElementID e)
instance Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.Graph.ElementID e)
instance Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.Graph.ElementID e)
instance Data.Aeson.Types.ToJSON.ToJSON (Data.Greskell.Graph.ElementID e)
instance GHC.Generics.Generic (Data.Greskell.Graph.ElementID e)
instance GHC.Classes.Eq (Data.Greskell.Graph.ElementID e)
instance GHC.Show.Show (Data.Greskell.Graph.ElementID e)
instance GHC.Classes.Eq (Data.Greskell.Graph.Key a b)
instance GHC.Show.Show (Data.Greskell.Graph.Key a b)
instance GHC.Classes.Eq Data.Greskell.Graph.AVertex
instance GHC.Show.Show Data.Greskell.Graph.AVertex
instance GHC.Classes.Eq Data.Greskell.Graph.AEdge
instance GHC.Show.Show Data.Greskell.Graph.AEdge
instance GHC.Classes.Ord v => GHC.Classes.Ord (Data.Greskell.Graph.AProperty v)
instance GHC.Classes.Eq v => GHC.Classes.Eq (Data.Greskell.Graph.AProperty v)
instance GHC.Show.Show v => GHC.Show.Show (Data.Greskell.Graph.AProperty v)
instance GHC.Classes.Eq v => GHC.Classes.Eq (Data.Greskell.Graph.AVertexProperty v)
instance GHC.Show.Show v => GHC.Show.Show (Data.Greskell.Graph.AVertexProperty v)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Greskell.Graph.PathEntry a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Greskell.Graph.PathEntry a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Greskell.Graph.PathEntry a)
instance GHC.Base.Monoid (Data.Greskell.Graph.Path a)
instance GHC.Base.Semigroup (Data.Greskell.Graph.Path a)
instance Data.Traversable.Traversable Data.Greskell.Graph.Path
instance Data.Foldable.Foldable Data.Greskell.Graph.Path
instance GHC.Base.Functor Data.Greskell.Graph.Path
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Greskell.Graph.Path a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Greskell.Graph.Path a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Greskell.Graph.Path a)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.Graph.Path a)
instance Data.Greskell.AsIterator.AsIterator (Data.Greskell.Graph.Path a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.Graph.Path a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.Graph.Path a)
instance GHC.Base.Functor Data.Greskell.Graph.PathEntry
instance Data.Foldable.Foldable Data.Greskell.Graph.PathEntry
instance Data.Traversable.Traversable Data.Greskell.Graph.PathEntry
instance Data.Greskell.Graph.Element Data.Greskell.Graph.AVertex
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.Graph.AVertexProperty v)
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.Graph.AVertexProperty v)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.Graph.AVertexProperty v)
instance Data.Greskell.Graph.ElementData (Data.Greskell.Graph.AVertexProperty v)
instance Data.Greskell.Graph.Element (Data.Greskell.Graph.AVertexProperty v)
instance Data.Greskell.Graph.Property Data.Greskell.Graph.AVertexProperty
instance GHC.Base.Functor Data.Greskell.Graph.AVertexProperty
instance Data.Foldable.Foldable Data.Greskell.Graph.AVertexProperty
instance Data.Traversable.Traversable Data.Greskell.Graph.AVertexProperty
instance Data.Greskell.Graph.Element Data.Greskell.Graph.AEdge
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.Graph.AProperty v)
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.Graph.AProperty v)
instance Data.Greskell.Graph.Property Data.Greskell.Graph.AProperty
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.Graph.AProperty v)
instance GHC.Base.Functor Data.Greskell.Graph.AProperty
instance Data.Foldable.Foldable Data.Greskell.Graph.AProperty
instance Data.Traversable.Traversable Data.Greskell.Graph.AProperty
instance Data.Greskell.Graph.ElementData Data.Greskell.Graph.AEdge
instance Data.Greskell.Graph.Edge Data.Greskell.Graph.AEdge
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped Data.Greskell.Graph.AEdge
instance Data.Aeson.Types.FromJSON.FromJSON Data.Greskell.Graph.AEdge
instance Data.Greskell.GraphSON.FromGraphSON Data.Greskell.Graph.AEdge
instance Data.Greskell.Graph.ElementData Data.Greskell.Graph.AVertex
instance Data.Greskell.Graph.Vertex Data.Greskell.Graph.AVertex
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped Data.Greskell.Graph.AVertex
instance Data.Aeson.Types.FromJSON.FromJSON Data.Greskell.Graph.AVertex
instance Data.Greskell.GraphSON.FromGraphSON Data.Greskell.Graph.AVertex
instance GHC.Base.Semigroup (Data.Greskell.Graph.Keys a)
instance GHC.Base.Monoid (Data.Greskell.Graph.Keys a)
instance GHC.Base.Functor (Data.Greskell.Graph.Key a)
instance Data.String.IsString (Data.Greskell.Graph.Key a b)
instance Data.Greskell.Greskell.ToGreskell (Data.Greskell.Graph.Key a b)
instance Data.Greskell.PMap.PMapKey (Data.Greskell.Graph.Key a b)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.Graph.T a b)
instance GHC.Base.Functor Data.Greskell.Graph.ElementID
-- | PropertyMap was used in greskell prior than 1.0.0.0, but is now
-- deprecated. Use Data.Greskell.PMap instead.
-- | Deprecated: Use PMap instead
module Data.Greskell.Graph.PropertyMap
-- | Common basic operations supported by maps of properties.
class PropertyMap m
-- | Look up a property associated with the given key.
lookupOne :: PropertyMap m => Text -> m p v -> Maybe (p v)
-- | Look up all properties associated with the given key.
lookupList :: PropertyMap m => Text -> m p v -> [p v]
-- | Put a property into the map.
putProperty :: (PropertyMap m, Property p) => p v -> m p v -> m p v
-- | Remove all properties associated with the given key.
removeProperty :: PropertyMap m => Text -> m p v -> m p v
-- | Return all properties in the map.
allProperties :: PropertyMap m => m p v -> [p v]
-- | A PropertyMap that has a single value per key.
--
-- putProperty replaces the old property by the given property.
--
-- <> returns the union of the two given property maps. If
-- the two property maps share some same keys, the value from the left
-- map wins.
data PropertyMapSingle p v
-- | A PropertyMap that can keep more than one values per key.
--
-- lookupOne returns the first property associated with the given
-- key.
--
-- putProperty prepends the given property to the property list.
--
-- <> returns the union of the two given property maps. If
-- the two property maps share some same keys, those property lists are
-- concatenated.
data PropertyMapList p v
-- | Lookup a property value from a PropertyMap by key.
lookupOneValue :: (PropertyMap m, Property p) => Text -> m p v -> Maybe v
-- | Lookup a list of property values from a PropertyMap by key.
lookupListValues :: (PropertyMap m, Property p) => Text -> m p v -> [v]
-- | Lookup a property GValue by the given key, and parse it.
--
-- In version 0.1.1.0 and before, this function took an argument m p
-- (GraphSON Value). This has changed, because property types for
-- AVertex etc have changed.
parseOneValue :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser v
-- | Lookup a list of property values from a PropertyMap by the
-- given key, and parse them.
--
-- In version 0.1.1.0 and before, this function took an argument m p
-- (GraphSON Value). This has changed, because property types for
-- AVertex etc have changed.
parseListValues :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser [v]
-- | Like parseListValues, but this function fails when there
-- is no property with the given key.
--
-- In version 0.1.1.0 and before, this function took an argument m p
-- (GraphSON Value). This has changed, because property types for
-- AVertex etc have changed.
parseNonEmptyValues :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser (NonEmpty v)
-- | Create a PropertyMap from list of Propertys.
fromProperties :: (PropertyMap m, Property p, Monoid (m p v)) => [p v] -> m p v
-- | This typeclass is for internal use.
--
-- GraphSON parser with a property key given from outside.
class FromGraphSONWithKey a
-- | General simple property type you can use for Property class.
--
-- If you are not sure about the type v, just use GValue.
data AProperty v
AProperty :: Text -> v -> AProperty v
[apKey] :: AProperty v -> Text
[apValue] :: AProperty v -> v
-- | General vertex property type you can use for VertexProperty.
--
-- If you are not sure about the type v, just use GValue.
data AVertexProperty v
AVertexProperty :: ElementID (AVertexProperty v) -> Text -> v -> AVertexProperty v
-- | ID of this vertex property.
[avpId] :: AVertexProperty v -> ElementID (AVertexProperty v)
-- | Label and key of this vertex property.
[avpLabel] :: AVertexProperty v -> Text
-- | Value of this vertex property.
[avpValue] :: AVertexProperty v -> v
instance GHC.Classes.Eq (t (p v)) => GHC.Classes.Eq (Data.Greskell.Graph.PropertyMap.PropertyMapGeneric t p v)
instance GHC.Show.Show (t (p v)) => GHC.Show.Show (Data.Greskell.Graph.PropertyMap.PropertyMapGeneric t p v)
instance Data.Traversable.Traversable p => Data.Traversable.Traversable (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p)
instance Data.Foldable.Foldable p => Data.Foldable.Foldable (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p)
instance GHC.Base.Functor p => GHC.Base.Functor (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p)
instance GHC.Base.Monoid (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p v)
instance GHC.Base.Semigroup (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p v)
instance GHC.Classes.Eq (p v) => GHC.Classes.Eq (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p v)
instance GHC.Show.Show (p v) => GHC.Show.Show (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p v)
instance Data.Traversable.Traversable p => Data.Traversable.Traversable (Data.Greskell.Graph.PropertyMap.PropertyMapList p)
instance Data.Foldable.Foldable p => Data.Foldable.Foldable (Data.Greskell.Graph.PropertyMap.PropertyMapList p)
instance GHC.Base.Functor p => GHC.Base.Functor (Data.Greskell.Graph.PropertyMap.PropertyMapList p)
instance GHC.Base.Monoid (Data.Greskell.Graph.PropertyMap.PropertyMapList p v)
instance GHC.Base.Semigroup (Data.Greskell.Graph.PropertyMap.PropertyMapList p v)
instance GHC.Classes.Eq (p v) => GHC.Classes.Eq (Data.Greskell.Graph.PropertyMap.PropertyMapList p v)
instance GHC.Show.Show (p v) => GHC.Show.Show (Data.Greskell.Graph.PropertyMap.PropertyMapList p v)
instance (Data.Greskell.Graph.Property p, Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (p v), Data.Greskell.GraphSON.FromGraphSON (p v), Data.Greskell.Graph.PropertyMap.FromGraphSONWithKey (p v)) => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p v)
instance (Data.Greskell.Graph.Property p, Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (p v), Data.Greskell.GraphSON.FromGraphSON (p v), Data.Greskell.Graph.PropertyMap.FromGraphSONWithKey (p v)) => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.Graph.PropertyMap.PropertyMapSingle p v)
instance (Data.Greskell.Graph.Property p, Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (p v), Data.Greskell.GraphSON.FromGraphSON (p v), Data.Greskell.Graph.PropertyMap.FromGraphSONWithKey (p v)) => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.Graph.PropertyMap.PropertyMapList p v)
instance (Data.Greskell.Graph.Property p, Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (p v), Data.Greskell.GraphSON.FromGraphSON (p v), Data.Greskell.Graph.PropertyMap.FromGraphSONWithKey (p v)) => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.Graph.PropertyMap.PropertyMapList p v)
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Greskell.Graph.PropertyMap.FromGraphSONWithKey (Data.Greskell.Graph.AProperty v)
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Greskell.Graph.PropertyMap.FromGraphSONWithKey (Data.Greskell.Graph.AVertexProperty v)
instance Data.Greskell.Graph.PropertyMap.PropertyMap Data.Greskell.Graph.PropertyMap.PropertyMapList
instance Data.Greskell.Graph.PropertyMap.PropertyMap Data.Greskell.Graph.PropertyMap.PropertyMapSingle
instance GHC.Base.Semigroup (t (p v)) => GHC.Base.Semigroup (Data.Greskell.Graph.PropertyMap.PropertyMapGeneric t p v)
instance GHC.Base.Semigroup (t (p v)) => GHC.Base.Monoid (Data.Greskell.Graph.PropertyMap.PropertyMapGeneric t p v)
instance (GHC.Base.Functor t, GHC.Base.Functor p) => GHC.Base.Functor (Data.Greskell.Graph.PropertyMap.PropertyMapGeneric t p)
instance (Data.Foldable.Foldable t, Data.Foldable.Foldable p) => Data.Foldable.Foldable (Data.Greskell.Graph.PropertyMap.PropertyMapGeneric t p)
instance (Data.Traversable.Traversable t, Data.Traversable.Traversable p) => Data.Traversable.Traversable (Data.Greskell.Graph.PropertyMap.PropertyMapGeneric t p)
-- | This module defines GTraversal, greskell counterpart of
-- GraphTraversal class object, and a DSL of composing graph
-- traversal steps.
module Data.Greskell.GTraversal
-- | 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 :: Greskell (GraphTraversal c s e) -> GTraversal c s e
[unGTraversal] :: GTraversal c s e -> Greskell (GraphTraversal c s e)
-- | Phantom type for GraphTraversal class. In greskell, we
-- usually use GTraversal instead of Greskell
-- GraphTraversal.
data GraphTraversal c s e
-- | Types that can convert to GTraversal.
class ToGTraversal g
toGTraversal :: (ToGTraversal g, WalkType c) => g c s e -> GTraversal c s e
-- | Lift WalkType from to to. Use this for type
-- matching.
liftWalk :: (ToGTraversal g, WalkType from, WalkType to, Lift from to) => g from s e -> g to s 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.
unsafeCastStart :: (ToGTraversal g, WalkType c) => g c s1 e -> g c s2 e
-- | Unsafely cast the end type e1 into e2. See
-- unsafeCastStart.
unsafeCastEnd :: (ToGTraversal g, WalkType c) => g c s e1 -> g c s e2
-- | A chain of one or more Gremlin steps. Like GTraversal, type
-- s is the input, type e is the output, and type
-- c is a marker to describe the step.
--
-- Walk represents a chain of method calls such as
-- .has(x).outE(). Because this is not a Gremlin (Groovy)
-- expression, we use bare Walk, not Greskell Walk.
--
-- Walk is a Category. You can use functions from
-- Control.Category to compose Walks. This is equivalent to
-- making a chain of method calls in Gremlin.
--
-- Walk is not an Eq, because it's difficult to define true
-- equality between Gremlin method calls. If we define it naively, it
-- might have conflict with Category law.
data Walk c s e
-- | GraphTraversalSource class object of TinkerPop. It is a
-- factory object of GraphTraversals.
data GraphTraversalSource
-- | Class of phantom type markers to describe the effect of the
-- walk/traversals.
class WalkType t
-- | 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 Walks w1 and w2 are Filter type,
-- then
--
--
-- gAnd [w1, w2] == w1 >>> w2 == w2 >>> w1
--
data 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 Walks are also
-- Transform type.
data 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
-- | Relation of WalkTypes where one includes the other.
-- from can be lifted to to, because to is
-- more powerful than from.
class Lift from to
-- | Relation of WalkTypes where the child walk c is split
-- from the parent walk p.
--
-- When splitting, transformation effect done in the child walk is rolled
-- back (canceled) in the parent walk.
class Split c p
-- | Create GraphTraversalSource from a varible name in Gremlin
--
--
-- >>> toGremlin $ source "g"
-- "g"
--
source :: Text -> Greskell GraphTraversalSource
-- | .V() method on GraphTraversalSource.
sV :: Vertex v => [Greskell (ElementID v)] -> Greskell GraphTraversalSource -> GTraversal Transform () v
-- | Monomorphic version of sV.
--
--
-- >>> toGremlin (source "g" & sV' (map (fmap ElementID . gvalueInt) ([1,2,3] :: [Int])))
-- "g.V(1,2,3)"
--
sV' :: [Greskell (ElementID AVertex)] -> Greskell GraphTraversalSource -> GTraversal Transform () AVertex
-- | .E() method on GraphTraversalSource.
sE :: Edge e => [Greskell (ElementID e)] -> Greskell GraphTraversalSource -> GTraversal Transform () e
-- | Monomorphic version of sE.
--
--
-- >>> toGremlin (source "g" & sE' (map (fmap ElementID . gvalueInt) ([1] :: [Int])))
-- "g.E(1)"
--
sE' :: [Greskell (ElementID AEdge)] -> Greskell GraphTraversalSource -> GTraversal Transform () AEdge
-- | .addV() method on GraphTraversalSource.
sAddV :: Vertex v => Greskell Text -> Greskell GraphTraversalSource -> GTraversal SideEffect () v
-- | Monomorphic version of sAddV.
--
--
-- >>> toGremlin (source "g" & sAddV' "person")
-- "g.addV(\"person\")"
--
sAddV' :: Greskell Text -> Greskell GraphTraversalSource -> GTraversal SideEffect () AVertex
-- | Apply the Walk to the GTraversal. In Gremlin, this means
-- calling a chain of methods on the Traversal object.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gValues ["age"])
-- "g.V().values(\"age\")"
--
(&.) :: GTraversal c a b -> Walk c b d -> GTraversal c a d
infixl 1 &.
-- | Same as &. with arguments flipped.
--
--
-- >>> toGremlin (gValues ["age"] $. sV' [] $ source "g")
-- "g.V().values(\"age\")"
--
($.) :: Walk c b d -> GTraversal c a b -> GTraversal c a d
infixr 0 $.
-- | Similar to <$>, but for $..
(<$.>) :: Functor f => Walk c b d -> f (GTraversal c a b) -> f (GTraversal c a d)
infixr 0 <$.>
-- | Similar to <*>, but for $..
(<*.>) :: Applicative f => f (Walk c b d) -> f (GTraversal c a b) -> f (GTraversal c a d)
infixr 0 <*.>
-- | .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 ().
--
--
-- >>> toGremlin (source "g" & sAddV' "person" &. gProperty "name" "marko" & gIterate)
-- "g.addV(\"person\").property(\"name\",\"marko\").iterate()"
--
gIterate :: WalkType c => GTraversal c s e -> GTraversal c s ()
-- | Unsafely create GTraversal from the given raw Gremlin script.
--
--
-- >>> toGremlin $ unsafeGTraversal "g.V().count()"
-- "g.V().count()"
--
unsafeGTraversal :: Text -> GTraversal c s e
-- | Unsafely create a Walk that represents a single method call on
-- a GraphTraversal.
--
--
-- >>> toGremlin (source "g" & sV' [] &. unsafeWalk "valueMap" ["'foo'", "'bar'"])
-- "g.V().valueMap('foo','bar')"
--
unsafeWalk :: WalkType c => Text -> [Text] -> Walk c s e
-- | Optionally modulate the main Walk with some modulating
-- Walks.
--
--
-- >>> toGremlin (source "g" & sV' [] &. modulateWith (unsafeWalk "path" []) [unsafeWalk "by" ["'name'"], unsafeWalk "by" ["'age'"]])
-- "g.V().path().by('name').by('age')"
--
modulateWith :: WalkType c => Walk c s e -> [Walk c e e] -> Walk c s e
-- | .identity step.
gIdentity :: WalkType c => Walk c s s
-- | Monomorphic version of gIdentity.
gIdentity' :: Walk Filter s s
-- | .filter step that takes a traversal.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gFilter (gOut' ["knows"]))
-- "g.V().filter(__.out(\"knows\"))"
--
gFilter :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
-- | .cyclicPath step.
gCyclicPath :: WalkType c => Walk c a a
-- | Monomorphic version of gCyclicPath.
gCyclicPath' :: Walk Filter a a
-- | .simplePath step.
gSimplePath :: WalkType c => Walk c a a
-- | Monomorphic version of gSimplePath.
gSimplePath' :: Walk Filter a a
-- | .is step of simple equality.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gValues ["age" :: Key AVertex Int] &. gIs 30)
-- "g.V().values(\"age\").is(30)"
--
gIs :: WalkType c => Greskell v -> Walk c v v
-- | Monomorphic version of gIs.
gIs' :: Greskell v -> Walk Filter v v
-- | .is step with predicate P.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gValues ["age" :: Key AVertex Int] &. gIsP (pLte 30))
-- "g.V().values(\"age\").is(P.lte(30))"
--
gIsP :: WalkType c => Greskell (P v) -> Walk c v v
-- | Monomorphic version of gIsP.
gIsP' :: Greskell (P v) -> Walk Filter v v
-- | .has step with one argument.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHas1 "age")
-- "g.V().has(\"age\")"
--
gHas1 :: (WalkType c, Element s) => Key s v -> Walk c s s
-- | Monomorphic version of gHas1.
gHas1' :: Element s => Key s v -> Walk Filter s s
-- | .has step with two arguments.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHas2 "age" (31 :: Greskell Int))
-- "g.V().has(\"age\",31)"
--
gHas2 :: (WalkType c, Element s) => Key s v -> Greskell v -> Walk c s s
-- | Monomorphic verson of gHas2.
gHas2' :: Element s => Key s v -> Greskell v -> Walk Filter s s
-- | .has step with two arguments and P type.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHas2P "age" (pBetween (30 :: Greskell Int) 40))
-- "g.V().has(\"age\",P.between(30,40))"
--
gHas2P :: (WalkType c, Element s) => Key s v -> Greskell (P v) -> Walk c s s
-- | Monomorphic version of gHas2P.
gHas2P' :: Element s => Key s v -> Greskell (P v) -> Walk Filter s s
-- | .hasLabel step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHasLabel "person")
-- "g.V().hasLabel(\"person\")"
--
gHasLabel :: (Element s, WalkType c) => Greskell Text -> Walk c s s
-- | Monomorphic version of gHasLabel.
gHasLabel' :: Element s => Greskell Text -> Walk Filter s s
-- | .hasLabel step with P type. Supported since TinkerPop
-- 3.2.7.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHasLabelP (pEq "person"))
-- "g.V().hasLabel(P.eq(\"person\"))"
--
gHasLabelP :: (Element s, WalkType c) => Greskell (P Text) -> Walk c s s
-- | Monomorphic version of gHasLabelP.
gHasLabelP' :: Element s => Greskell (P Text) -> Walk Filter s s
-- | .hasId step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHasId (fmap ElementID $ gvalueInt $ (7 :: Int)))
-- "g.V().hasId(7)"
--
gHasId :: (Element s, WalkType c) => Greskell (ElementID s) -> Walk c s s
-- | Monomorphic version of gHasId.
gHasId' :: Element s => Greskell (ElementID s) -> Walk Filter s s
-- | .hasId step with P type. Supported since TinkerPop
-- 3.2.7.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHasIdP (pLte $ fmap ElementID $ gvalueInt (100 :: Int)))
-- "g.V().hasId(P.lte(100))"
--
gHasIdP :: (Element s, WalkType c) => Greskell (P (ElementID s)) -> Walk c s s
-- | Monomorphic version of gHasIdP.
gHasIdP' :: Element s => Greskell (P (ElementID s)) -> Walk Filter s s
-- | .hasKey step. The input type should be a VertexProperty.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gProperties [] &. gHasKey "age")
-- "g.V().properties().hasKey(\"age\")"
--
gHasKey :: (Element (p v), Property p, WalkType c) => Greskell Text -> Walk c (p v) (p v)
-- | Monomorphic version of gHasKey.
gHasKey' :: (Element (p v), Property p) => Greskell Text -> Walk Filter (p v) (p v)
-- | .hasKey step with P type. Supported since TinkerPop
-- 3.2.7.
gHasKeyP :: (Element (p v), Property p, WalkType c) => Greskell (P Text) -> Walk c (p v) (p v)
-- | Monomorphic version of gHasKeyP.
gHasKeyP' :: (Element (p v), Property p) => Greskell (P Text) -> Walk Filter (p v) (p v)
-- | .hasValue step. The input type should be a VertexProperty.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gProperties ["age"] &. gHasValue (32 :: Greskell Int))
-- "g.V().properties(\"age\").hasValue(32)"
--
gHasValue :: (Element (p v), Property p, WalkType c) => Greskell v -> Walk c (p v) (p v)
-- | Monomorphic version of gHasValue.
gHasValue' :: (Element (p v), Property p) => Greskell v -> Walk Filter (p v) (p v)
-- | .hasValue step with P type. Supported since TinkerPop
-- 3.2.7.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gProperties ["age"] &. gHasValueP (pBetween (30 :: Greskell Int) 40))
-- "g.V().properties(\"age\").hasValue(P.between(30,40))"
--
gHasValueP :: (Element (p v), Property p, WalkType c) => Greskell (P v) -> Walk c (p v) (p v)
-- | Monomorphic version of gHasValueP.
gHasValueP' :: (Element (p v), Property p) => Greskell (P v) -> Walk Filter (p v) (p v)
-- | .and step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gAnd [gOut' ["knows"], gHas1 "age"])
-- "g.V().and(__.out(\"knows\"),__.has(\"age\"))"
--
gAnd :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s
-- | .or step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gOr [gOut' ["knows"], gHas1 "age"])
-- "g.V().or(__.out(\"knows\"),__.has(\"age\"))"
--
gOr :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => [g c s e] -> Walk p s s
-- | .not step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gNot (gOut' ["knows"]))
-- "g.V().not(__.out(\"knows\"))"
--
gNot :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
-- | .where step with P argument only.
--
--
-- >>> let la = ("a" :: AsLabel AVertex)
--
-- >>> let age = ("age" :: Key AVertex Int)
--
-- >>> toGremlin (source "g" & sV' [] &. gAs la &. gOut' [] &. gWhereP1 (pEq la) (Just $ gBy age))
-- "g.V().as(\"a\").out().where(P.eq(\"a\")).by(\"age\")"
--
--
-- 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.
gWhereP1 :: WalkType c => Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c a a
-- | Monomorphic version of gWhereP1.
gWhereP1' :: Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter a a
-- | .where step with the starting label and P arguments.
-- See also gWhereP1.
--
--
-- >>> let la = ("a" :: AsLabel AVertex)
--
-- >>> let lb = ("b" :: AsLabel AVertex)
--
-- >>> let age = ("age" :: Key AVertex Int)
--
-- >>> toGremlin (source "g" & sV' [] &. gAs la &. gOut' [] &. gAs lb &. gValues [age] &. gWhereP2 la (pEq lb) Nothing)
-- "g.V().as(\"a\").out().as(\"b\").values(\"age\").where(\"a\",P.eq(\"b\"))"
--
gWhereP2 :: WalkType c => AsLabel a -> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk c x x
-- | Monomorphic version of gWhereP2.
gWhereP2' :: AsLabel a -> Greskell (LabeledP a) -> Maybe (ByProjection a b) -> Walk Filter x x
-- | .order step.
--
--
-- >>> let key_age = ("age" :: Key AVertex Int)
--
-- >>> toGremlin (source "g" & sV' [] &. gOrder [gBy1 key_age])
-- "g.V().order().by(\"age\")"
--
-- >>> toGremlin (source "g" & sV' [] &. gOrder [gBy2 key_age oDecr, gBy1 tId])
-- "g.V().order().by(\"age\",Order.decr).by(T.id)"
--
-- >>> toGremlin (source "g" & sV' [] &. gOrder [gBy2 (gOut' ["knows"] >>> gCount) oIncr, gBy2 tId oIncr])
-- "g.V().order().by(__.out(\"knows\").count(),Order.incr).by(T.id,Order.incr)"
--
--
-- ByComparator is an IsString, meaning projection by the
-- given key.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gOrder ["age"])
-- "g.V().order().by(\"age\")"
--
gOrder :: [ByComparator s] -> Walk Transform s s
-- | .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.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRange 0 100)
-- "g.V().range(0,100)"
--
gRange :: Greskell Int -> Greskell Int -> Walk Transform s s
-- | .limit step.
gLimit :: Greskell Int -> Walk Transform s s
-- | .tail step.
gTail :: Greskell Int -> Walk Transform s s
-- | .skip step.
gSkip :: Greskell Int -> Walk Transform s s
-- | .repeat step.
gRepeat :: (ToGTraversal g, WalkType c) => Maybe RepeatLabel -> Maybe (RepeatPos, RepeatUntil c s) -> Maybe (RepeatPos, RepeatEmit c s) -> g c s s -> Walk c s s
-- | .times modulator before the .repeat step. It always
-- returns Just.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat Nothing (gTimes 3) Nothing (gOut' []))
-- "g.V().times(3).repeat(__.out())"
--
gTimes :: Greskell Int -> Maybe (RepeatPos, RepeatUntil c s)
-- | .until modulator before the .repeat step. It always
-- returns Just.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat Nothing (gUntilHead $ gHasLabel' "person") Nothing (gOut' []))
-- "g.V().until(__.hasLabel(\"person\")).repeat(__.out())"
--
gUntilHead :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
-- | .until modulator after the .repeat step. It always
-- returns Just.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat Nothing (gUntilTail $ gHasLabel' "person") Nothing (gOut' []))
-- "g.V().repeat(__.out()).until(__.hasLabel(\"person\"))"
--
gUntilTail :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatUntil c s)
-- | .emit modulator without argument before the .repeat
-- step. It always returns Just.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat Nothing Nothing gEmitHead (gOut' []))
-- "g.V().emit().repeat(__.out())"
--
gEmitHead :: Maybe (RepeatPos, RepeatEmit c s)
-- | .emit modulator without argument after the .repeat
-- step. It always returns Just.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat Nothing Nothing gEmitTail (gOut' []))
-- "g.V().repeat(__.out()).emit()"
--
gEmitTail :: Maybe (RepeatPos, RepeatEmit c s)
-- | .emit modulator with a sub-traversal argument before the
-- .repeat step. It always returns Just.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat Nothing Nothing (gEmitHeadT $ gHasLabel' "person") (gOut' []))
-- "g.V().emit(__.hasLabel(\"person\")).repeat(__.out())"
--
gEmitHeadT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
-- | .emit modulator with a sub-traversal argument after the
-- .repeat step. It always returns Just.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat Nothing Nothing (gEmitTailT $ gHasLabel' "person") (gOut' []))
-- "g.V().repeat(__.out()).emit(__.hasLabel(\"person\"))"
--
gEmitTailT :: (ToGTraversal g, WalkType c, WalkType cc, Split cc c) => g cc s e -> Maybe (RepeatPos, RepeatEmit c s)
-- | .loops step.
--
--
-- >>> let loop_label = Just "the_loop"
--
-- >>> toGremlin (source "g" & sV' [] &. gRepeat loop_label (gUntilTail $ gLoops loop_label >>> gIs 3) Nothing (gOut' []))
-- "g.V().repeat(\"the_loop\",__.out()).until(__.loops(\"the_loop\").is(3))"
--
gLoops :: Maybe RepeatLabel -> Walk Transform s Int
-- | .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.
data RepeatUntil c s
-- | .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
-- | .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.
data RepeatEmit c s
-- | .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
-- | Position of a step modulator relative to .repeat step.
data RepeatPos
-- | Modulator before the .repeat step.
RepeatHead :: RepeatPos
-- | Modulator after the .repeat step.
RepeatTail :: RepeatPos
-- | A label that points to a loop created by .repeat step. It can
-- be used by .loops step to specify the loop.
newtype RepeatLabel
RepeatLabel :: Text -> RepeatLabel
[unRepeatLabel] :: RepeatLabel -> Text
-- | .local step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gLocal ( gOut' [] >>> gLimit 3 ))
-- "g.V().local(__.out().limit(3))"
--
gLocal :: (ToGTraversal g, WalkType c) => g c s e -> Walk c s e
-- | .union step.
--
--
-- >>> let key_age = ("age" :: Key AVertex Int)
--
-- >>> let key_birth_year = ("birth_year" :: Key AVertex Int)
--
-- >>> toGremlin (source "g" & sV' [] &. gUnion [gValues [key_age], gValues [key_birth_year]])
-- "g.V().union(__.values(\"age\"),__.values(\"birth_year\"))"
--
gUnion :: (ToGTraversal g, WalkType c) => [g c s e] -> Walk c s e
-- | .coalesce step.
--
-- Like gFlatMap, gCoalesce always modifies path history.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gCoalesce [gOut' [], gIn' []])
-- "g.V().coalesce(__.out(),__.in())"
--
gCoalesce :: (ToGTraversal g, Split cc c, Lift Transform c, WalkType c, WalkType cc) => [g cc s e] -> Walk c s e
-- | .choose step with if-then-else style.
--
--
-- >>> let key_age = ("age" :: Key AVertex Int)
--
-- >>> toGremlin (source "g" & sV' [] &. gChoose3 (gHas2' key_age 30) (gIn' []) (gOut' []))
-- "g.V().choose(__.has(\"age\",30),__.in(),__.out())"
--
gChoose3 :: (ToGTraversal g, Split cc c, WalkType cc, WalkType c) => g cc s ep -> g c s e -> g c s e -> Walk c s e
-- | .barrier step.
gBarrier :: WalkType c => Maybe (Greskell Int) -> Walk c s s
-- | .dedup step without argument.
--
-- .dedup step is Transform because the filtering
-- decision depends on the sequence (order) of input elements.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gDedup Nothing)
-- "g.V().dedup()"
--
-- >>> let key_age = ("age" :: Key AVertex Int)
--
-- >>> toGremlin (source "g" & sV' [] &. gDedup (Just $ gBy key_age))
-- "g.V().dedup().by(\"age\")"
--
gDedup :: Maybe (ByProjection s e) -> Walk Transform s s
-- | .dedup step with at least one argument. The tuple specified
-- by the AsLabels is used as the criterion of deduplication.
--
--
-- >>> let label_a = ("a" :: AsLabel AVertex)
--
-- >>> let label_b = ("b" :: AsLabel AVertex)
--
-- >>> toGremlin (source "g" & sV' [] &. gAs label_a &. gOut' [] &. gAs label_b &. gDedupN label_a [label_b] Nothing)
-- "g.V().as(\"a\").out().as(\"b\").dedup(\"a\",\"b\")"
--
gDedupN :: AsLabel a -> [AsLabel a] -> Maybe (ByProjection a e) -> Walk Transform s s
-- | .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.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gFlatMap (gOut' ["knows"] >>> gOut' ["created"]))
-- "g.V().flatMap(__.out(\"knows\").out(\"created\"))"
--
gFlatMap :: (Lift Transform c, Split cc c, ToGTraversal g, WalkType c, WalkType cc) => g cc s e -> Walk c s e
-- | Monomorphic version of gFlatMap.
gFlatMap' :: ToGTraversal g => g Transform s e -> Walk Transform s e
-- | .V step.
--
-- For each input item, .V step emits vertices selected by the
-- argument (or all vertices if the empty list is passed.)
gV :: Vertex v => [Greskell (ElementID v)] -> Walk Transform s v
-- | Monomorphic version of gV.
gV' :: [Greskell (ElementID AVertex)] -> Walk Transform s AVertex
-- | .constant step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gConstant (10 :: Greskell Int))
-- "g.V().constant(10)"
--
gConstant :: Greskell a -> Walk Transform s a
-- | .project step.
--
--
-- >>> let name_label = ("a" :: AsLabel Text)
--
-- >>> let name_key = ("name" :: Key AVertex Text)
--
-- >>> let count_label = ("b" :: AsLabel Int)
--
-- >>> toGremlin (source "g" & sV' [] &. gProject (gByL name_label name_key) [gByL count_label (gOut' [] >>> gCount), gByL "c" tId])
-- "g.V().project(\"a\",\"b\",\"c\").by(\"name\").by(__.out().count()).by(T.id)"
--
gProject :: LabeledByProjection s -> [LabeledByProjection s] -> Walk Transform s (PMap Single GValue)
-- | .as step.
--
-- .as step is Transform because it adds the label to the
-- traverser.
gAs :: AsLabel a -> Walk Transform a a
-- | .values step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gValues ["name", "age"])
-- "g.V().values(\"name\",\"age\")"
--
gValues :: Element s => [Key s e] -> Walk Transform s e
-- | .properties step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gProperties ["age"])
-- "g.V().properties(\"age\")"
--
gProperties :: (Element s, Property p, ElementProperty s ~ p) => [Key s v] -> Walk Transform s (p v)
-- | .id step.
gId :: Element s => Walk Transform s (ElementID s)
-- | .label step.
gLabel :: Element s => Walk Transform s Text
-- | .valueMap step.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gValueMap KeysNil)
-- "g.V().valueMap()"
--
-- >>> toGremlin (source "g" & sV' [] &. gValueMap ("name" -: "age" -: KeysNil))
-- "g.V().valueMap(\"name\",\"age\")"
--
gValueMap :: Element s => Keys s -> Walk Transform s (PMap (ElementPropertyContainer s) GValue)
-- | .select step with one argument.
gSelect1 :: AsLabel a -> Walk Transform s a
-- | .select step with more than one arguments.
gSelectN :: AsLabel a -> AsLabel b -> [AsLabel c] -> Walk Transform s (SelectedMap GValue)
-- | .select step with one argument followed by .by step.
gSelectBy1 :: AsLabel a -> ByProjection a b -> Walk Transform s b
-- | .select step with more than one arguments followed by
-- .by step.
gSelectByN :: AsLabel a -> AsLabel a -> [AsLabel a] -> ByProjection a b -> Walk Transform s (SelectedMap b)
-- | .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.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gFold &. gUnfold)
-- "g.V().fold().unfold()"
--
gUnfold :: AsIterator a => Walk Transform a (IteratorItem a)
-- | .path step without modulation.
gPath :: Walk Transform s (Path GValue)
-- | .path step with one or more .by modulations.
--
--
-- >>> let inE = (gInE' [] :: Walk Transform AVertex AEdge)
--
-- >>> toGremlin (source "g" & sV' [] &. gOut' [] &. gPathBy "name" [gBy $ inE >>> gValues ["relation"]])
-- "g.V().out().path().by(\"name\").by(__.inE().values(\"relation\"))"
--
gPathBy :: ByProjection a b -> [ByProjection a b] -> Walk Transform s (Path b)
-- | .fold step.
gFold :: Walk Transform a [a]
-- | .count step.
gCount :: Walk Transform a Int
-- | .out step
gOut :: (Vertex v1, Vertex v2) => [Greskell Text] -> Walk Transform v1 v2
-- | Monomorphic version of gOut.
--
--
-- >>> toGremlin (source "g" & sV' [fmap ElementID $ gvalueInt (8 :: Int)] &. gOut' ["knows"])
-- "g.V(8).out(\"knows\")"
--
gOut' :: Vertex v => [Greskell Text] -> Walk Transform v AVertex
-- | .outE step
gOutE :: (Vertex v, Edge e) => [Greskell Text] -> Walk Transform v e
-- | Monomorphic version of gOutE.
gOutE' :: Vertex v => [Greskell Text] -> Walk Transform v AEdge
-- | .outV step.
gOutV :: (Edge e, Vertex v) => Walk Transform e v
-- | Monomorphic version of gOutV.
gOutV' :: Edge e => Walk Transform e AVertex
-- | .in step
gIn :: (Vertex v1, Vertex v2) => [Greskell Text] -> Walk Transform v1 v2
-- | Monomorphic version of gIn.
gIn' :: Vertex v => [Greskell Text] -> Walk Transform v AVertex
-- | .inE step.
gInE :: (Vertex v, Edge e) => [Greskell Text] -> Walk Transform v e
-- | Monomorphic version of gInE.
gInE' :: Vertex v => [Greskell Text] -> Walk Transform v AEdge
-- | .inV step.
gInV :: (Edge e, Vertex v) => Walk Transform e v
-- | Monomorphic version of gInV.
gInV' :: Edge e => Walk Transform e AVertex
-- | .match step.
--
-- If the top-level Logic of the argument is And, the
-- patterns are directly passed to the .match step arguments.
--
-- The result of .match step, MatchResult, is an opaque
-- type. Basically you should not use it. Instead, you should use
-- gSelectN etc to access the path history labels inside the
-- MatchPattern.
--
-- See also:
-- https://groups.google.com/g/gremlin-users/c/HVtldzV0Xk8
--
--
-- >>> :{
-- let
-- label_a = ("a" :: AsLabel AVertex)
-- label_b = "b"
-- key_age = ("age" :: Key AVertex Int)
-- patterns = Logic.And
-- ( mPattern label_a (gOut' [] >>> gAs label_b) )
-- [ mPattern label_b (gHas2' key_age 25)
-- ]
-- in toGremlin (source "g" & sV' [] &. gMatch patterns &. gSelectN label_a label_b [])
-- :}
-- "g.V().match(__.as(\"a\").out().as(\"b\"),__.as(\"b\").has(\"age\",25)).select(\"a\",\"b\")"
--
gMatch :: Logic MatchPattern -> Walk Transform a MatchResult
-- | A pattern for .match step.
data MatchPattern
-- | A pattern with the starting .as label followed by traversal
-- steps.
[MatchPattern] :: AsLabel a -> Walk Transform a b -> MatchPattern
-- | A convenient function to make a MatchPattern wrapped by
-- Leaf.
mPattern :: (WalkType c, Lift c Transform) => AsLabel a -> Walk c a b -> Logic MatchPattern
-- | Result of .match step.
data MatchResult
-- | .sideEffect step that takes a traversal.
gSideEffect :: (ToGTraversal g, WalkType c, WalkType p, Split c p) => g c s e -> Walk p s s
-- | Monomorphic version of gSideEffect. The result walk is always
-- SideEffect type.
--
--
-- >>> toGremlin (source "g" & sV' [] & liftWalk &. gHas2 "name" "marko" &. gSideEffect' (gAddV' "toshio"))
-- "g.V().has(\"name\",\"marko\").sideEffect(__.addV(\"toshio\"))"
--
gSideEffect' :: (ToGTraversal g, WalkType c, Split c SideEffect) => g c s e -> Walk SideEffect s s
-- | .addV step with a label.
gAddV :: Vertex v => Greskell Text -> Walk SideEffect a v
-- | Monomorphic version of gAddV.
gAddV' :: Greskell Text -> Walk SideEffect a AVertex
-- | .addE step. Supported since TinkerPop 3.1.0.
--
--
-- >>> let key_name = "name" :: Key AVertex Text
--
-- >>> toGremlin (source "g" & sV' [] & liftWalk &. gAddE' "knows" (gFrom $ gV' [] >>> gHas2 key_name "marko"))
-- "g.V().addE(\"knows\").from(__.V().has(\"name\",\"marko\"))"
--
-- >>> toGremlin (source "g" & sV' [] &. gHas2 key_name "marko" & liftWalk &. gAddE' "knows" (gTo $ gV' []))
-- "g.V().has(\"name\",\"marko\").addE(\"knows\").to(__.V())"
--
gAddE :: (Vertex vs, Vertex ve, Edge e) => Greskell Text -> AddAnchor vs ve -> Walk SideEffect vs e
-- | Monomorphic version of gAddE.
gAddE' :: Greskell Text -> AddAnchor AVertex AVertex -> Walk SideEffect AVertex AEdge
-- | 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.
data AddAnchor s e
-- | .from step with a traversal.
gFrom :: ToGTraversal g => g Transform s e -> AddAnchor s e
-- | .to step with a traversal.
gTo :: ToGTraversal g => g Transform s e -> AddAnchor s e
-- | .drop step on Element.
--
--
-- >>> toGremlin (source "g" & sV' [] &. gHas2 "name" "marko" & liftWalk &. gDrop)
-- "g.V().has(\"name\",\"marko\").drop()"
--
gDrop :: Element e => Walk SideEffect e e
-- | .drop step on Property.
--
--
-- >>> toGremlin (source "g" & sE' [] &. gProperties ["weight"] & liftWalk &. gDropP)
-- "g.E().properties(\"weight\").drop()"
--
gDropP :: Property p => Walk SideEffect (p a) (p a)
-- | Simple .property step. It adds a value to the property.
--
--
-- >>> toGremlin (source "g" & sV' [] & liftWalk &. gProperty "age" (20 :: Greskell Int))
-- "g.V().property(\"age\",20)"
--
gProperty :: Element e => Key e v -> Greskell v -> Walk SideEffect e e
-- | .property step for Vertex.
--
--
-- >>> let key_location = "location" :: Key AVertex Text
--
-- >>> let key_since = "since" :: Key (AVertexProperty Text) Text
--
-- >>> let key_score = "score" :: Key (AVertexProperty Text) Int
--
-- >>> toGremlin (source "g" & sV' [] & liftWalk &. gPropertyV (Just cList) key_location "New York" [key_since =: "2012-09-23", key_score =: 8])
-- "g.V().property(list,\"location\",\"New York\",\"since\",\"2012-09-23\",\"score\",8)"
--
gPropertyV :: (Vertex e, vp ~ ElementProperty e, Property vp, Element (vp v)) => Maybe (Greskell Cardinality) -> Key e v -> Greskell v -> [KeyValue (vp v)] -> Walk SideEffect e e
-- | Projection from type s to type e used in
-- .by step. You can also use gBy to construct
-- ByProjection.
data ByProjection s e
[ByProjection] :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
-- | Data types that mean a projection from one type to another.
class ProjectionLike p where {
-- | The start type of the projection.
type family ProjectionLikeStart p;
-- | The end type of the projection.
type family ProjectionLikeEnd p;
}
-- | Comparison of type s used in .by step. You can also
-- use gBy1 and gBy2 to construct ByComparator.
data ByComparator s
-- | 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
-- | A ByProjection associated with an AsLabel. You can
-- construct it by gByL.
data LabeledByProjection s
[LabeledByProjection] :: AsLabel a -> ByProjection s a -> LabeledByProjection s
-- | .by step with 1 argument, used for projection.
gBy :: (ProjectionLike p, ToGreskell p) => p -> ByProjection (ProjectionLikeStart p) (ProjectionLikeEnd p)
-- | .by step with 1 argument, used for comparison.
gBy1 :: (ProjectionLike p, ToGreskell p) => p -> ByComparator (ProjectionLikeStart p)
-- | .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)
-- | .by step associated with an AsLabel.
gByL :: (ProjectionLike p, ToGreskell p) => AsLabel (ProjectionLikeEnd p) -> p -> LabeledByProjection (ProjectionLikeStart p)
instance GHC.Show.Show (Data.Greskell.GTraversal.GraphTraversal c s e)
instance GHC.Show.Show (Data.Greskell.GTraversal.GTraversal c s e)
instance GHC.Show.Show (Data.Greskell.GTraversal.Walk c s e)
instance GHC.Show.Show Data.Greskell.GTraversal.GraphTraversalSource
instance Data.String.IsString Data.Greskell.GTraversal.RepeatLabel
instance GHC.Classes.Ord Data.Greskell.GTraversal.RepeatLabel
instance GHC.Classes.Eq Data.Greskell.GTraversal.RepeatLabel
instance GHC.Show.Show Data.Greskell.GTraversal.RepeatLabel
instance GHC.Enum.Bounded Data.Greskell.GTraversal.RepeatPos
instance GHC.Enum.Enum Data.Greskell.GTraversal.RepeatPos
instance GHC.Classes.Ord Data.Greskell.GTraversal.RepeatPos
instance GHC.Classes.Eq Data.Greskell.GTraversal.RepeatPos
instance GHC.Show.Show Data.Greskell.GTraversal.RepeatPos
instance GHC.Show.Show (Data.Greskell.GTraversal.MWalk c s e)
instance GHC.Show.Show (Data.Greskell.GTraversal.RepeatUntil c s)
instance GHC.Show.Show (Data.Greskell.GTraversal.RepeatEmit c s)
instance Data.Greskell.GTraversal.WalkType c => GHC.Base.Semigroup (Data.Greskell.GTraversal.MWalk c s s)
instance Data.Greskell.GTraversal.WalkType c => GHC.Base.Monoid (Data.Greskell.GTraversal.MWalk c s s)
instance Data.String.IsString (Data.Greskell.GTraversal.ByComparator s)
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.GTraversal.ByProjection s e)
instance Data.String.IsString (Data.Greskell.GTraversal.ByProjection s e)
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.GTraversal.Walk Data.Greskell.GTraversal.Filter s e)
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.GTraversal.GTraversal Data.Greskell.GTraversal.Filter s e)
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.Greskell.Greskell (Data.Greskell.GTraversal.GraphTraversal Data.Greskell.GTraversal.Filter s e))
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.GTraversal.Walk Data.Greskell.GTraversal.Transform s e)
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.GTraversal.GTraversal Data.Greskell.GTraversal.Transform s e)
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.Greskell.Greskell (Data.Greskell.GTraversal.GraphTraversal Data.Greskell.GTraversal.Transform s e))
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.Graph.Key s e)
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.Greskell.Greskell (Data.Greskell.Graph.T s e))
instance Data.Greskell.GTraversal.ProjectionLike (Data.Greskell.Greskell.Greskell (s -> e))
instance Data.Greskell.Greskell.ToGreskell Data.Greskell.GTraversal.RepeatLabel
instance Data.Greskell.GTraversal.WalkType p => Data.Greskell.GTraversal.Split Data.Greskell.GTraversal.Filter p
instance Data.Greskell.GTraversal.WalkType p => Data.Greskell.GTraversal.Split Data.Greskell.GTraversal.Transform p
instance Data.Greskell.GTraversal.Split Data.Greskell.GTraversal.SideEffect Data.Greskell.GTraversal.SideEffect
instance Data.Greskell.GTraversal.ToGTraversal Data.Greskell.GTraversal.GTraversal
instance Data.Greskell.GTraversal.ToGTraversal Data.Greskell.GTraversal.Walk
instance Data.Greskell.GTraversal.WalkType c => Data.Greskell.Greskell.ToGreskell (Data.Greskell.GTraversal.Walk c s e)
instance Data.Greskell.GTraversal.WalkType c => Data.Greskell.GTraversal.Lift Data.Greskell.GTraversal.Filter c
instance Data.Greskell.GTraversal.Lift Data.Greskell.GTraversal.Transform Data.Greskell.GTraversal.Transform
instance Data.Greskell.GTraversal.Lift Data.Greskell.GTraversal.Transform Data.Greskell.GTraversal.SideEffect
instance Data.Greskell.GTraversal.Lift Data.Greskell.GTraversal.SideEffect Data.Greskell.GTraversal.SideEffect
instance Data.Greskell.GTraversal.WalkType Data.Greskell.GTraversal.SideEffect
instance Data.Greskell.GTraversal.WalkType Data.Greskell.GTraversal.Transform
instance Data.Greskell.GTraversal.WalkType Data.Greskell.GTraversal.Filter
instance Data.Greskell.GTraversal.WalkType c => Control.Category.Category (Data.Greskell.GTraversal.Walk c)
instance Data.Greskell.GTraversal.WalkType c => GHC.Base.Semigroup (Data.Greskell.GTraversal.Walk c s s)
instance Data.Greskell.GTraversal.WalkType c => GHC.Base.Monoid (Data.Greskell.GTraversal.Walk c s s)
instance GHC.Base.Functor (Data.Greskell.GTraversal.Walk c s)
instance Data.Bifunctor.Bifunctor (Data.Greskell.GTraversal.Walk c)
instance GHC.Base.Functor (Data.Greskell.GTraversal.GTraversal c s)
instance Data.Bifunctor.Bifunctor (Data.Greskell.GTraversal.GTraversal c)
instance Data.Greskell.Greskell.ToGreskell (Data.Greskell.GTraversal.GTraversal c s e)
instance Data.Greskell.AsIterator.AsIterator (Data.Greskell.GTraversal.GraphTraversal c s e)
instance GHC.Base.Functor (Data.Greskell.GTraversal.GraphTraversal c s)
instance Data.Bifunctor.Bifunctor (Data.Greskell.GTraversal.GraphTraversal c)
module Data.Greskell.Binder
-- | A Monad that manages binding variables and labels to values.
--
--
-- >>> let binder = (,) <$> newBind (10 :: Int) <*> newBind "hoge"
--
-- >>> let ((var_int, var_str), binding) = runBinder binder
--
-- >>> toGremlin var_int
-- "__v0"
--
-- >>> toGremlin var_str
-- "__v1"
--
-- >>> sortBy (comparing fst) $ HashMap.toList binding
-- [("__v0",Number 10.0),("__v1",String "hoge")]
--
data Binder a
-- | Binding between Gremlin variable names and JSON values.
type Binding = Object
-- | Create a new Gremlin variable bound to the given value.
--
-- The value v is kept in the monadic context. The returned
-- Greskell is a Gremlin variable pointing to the v. The
-- Gremlin variable is guaranteed to be unique in the current monadic
-- context.
newBind :: ToJSON v => v -> Binder (Greskell v)
-- | Create a new AsLabel.
--
-- The returned AsLabel is guaranteed to be unique in the current
-- monadic context.
newAsLabel :: Binder (AsLabel a)
-- | Execute the given Binder monad to obtain Binding.
runBinder :: Binder a -> (a, Binding)
instance GHC.Classes.Eq Data.Greskell.Binder.BinderS
instance GHC.Show.Show Data.Greskell.Binder.BinderS
instance GHC.Base.Monad Data.Greskell.Binder.Binder
instance GHC.Base.Applicative Data.Greskell.Binder.Binder
instance GHC.Base.Functor Data.Greskell.Binder.Binder
-- | Extra utility functions implemented by Greskell.
module Data.Greskell.Extra
-- | Lookup the value and parse it into a.
lookupAs :: (PMapKey k, NonEmptyLike c, PMapValue k ~ a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException a
-- | Similar to lookupAs, but this function converts a null
-- result into Nothing.
--
-- A null result is either (1) the key k is not found
-- in the map, or (2) the key is found, but the value is null.
lookupAs' :: (PMapKey k, NonEmptyLike c, PMapValue k ~ Maybe a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException (Maybe a)
-- | Look up the values and parse them into a.
lookupListAs :: (PMapKey k, NonEmptyLike c, PMapValue k ~ a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException (NonEmpty a)
-- | Similar to lookupListAs, but this function accepts
-- null results.
--
-- If the key k is not found in the map, it returns an empty
-- list. If the key k is found and nulls are included
-- in the values, they are obtained as Nothing.
lookupListAs' :: (PMapKey k, NonEmptyLike c, PMapValue k ~ Maybe a, FromGraphSON a) => k -> PMap c GValue -> Either PMapLookupException [Maybe a]
-- | Convert the lookup result into a MonadFail. It fails with the
-- description returned by pMapDecribeError.
pMapToFail :: MonadFail m => Either PMapLookupException a -> m a
-- | Make a series of .property steps to write the given key-value
-- pairs as properties. Use <=:> and <=?> to
-- make a KeyValue within Binder.
--
--
-- >>> let keyAge = ("age" :: Key AVertex Int)
--
-- >>> let keyName = ("name" :: Key AVertex Text)
--
-- >>> let (walk, binding) = runBinder $ writeKeyValues <$> sequence [keyAge <=:> 21, keyName <=:> "Josh"]
--
-- >>> toGremlin walk
-- "__.property(\"age\",__v0).property(\"name\",__v1).identity()"
--
-- >>> sortBy (comparing fst) $ HashMap.toList binding
-- [("__v0",Number 21.0),("__v1",String "Josh")]
--
writeKeyValues :: Element e => [KeyValue e] -> Walk SideEffect e e
-- | Like =:, but this one takes a real value, binds it into a
-- Greskell value and returns KeyValue.
(<=:>) :: ToJSON b => Key a b -> b -> Binder (KeyValue a)
-- | Like <=:>, but this one is for an optional property. If
-- the value is Just, it's equivalent to <=:>. If the
-- value is Nothing, it returns KeyNoValue.
--
--
-- >>> let keyNName = ("nickname" :: Key AVertex (Maybe Text))
--
-- >>> let keyCompany = ("company" :: Key AVertex (Maybe Text))
--
-- >>> let (walk, binding) = runBinder $ writeKeyValues <$> sequence [keyNName <=?> Nothing, keyCompany <=?> Just "foobar.com"]
--
-- >>> toGremlin walk
-- "__.property(\"company\",__v0).identity()"
--
-- >>> sortBy (comparing fst) $ HashMap.toList binding
-- [("__v0",String "foobar.com")]
--
(<=?>) :: ToJSON b => Key a (Maybe b) -> Maybe b -> Binder (KeyValue a)
-- | Make a series of .property steps to write the given key-value
-- pairs as properties.
--
--
-- >>> let binder = (writePropertyKeyValues [("age", (21 :: Int))] :: Binder (Walk SideEffect AVertex AVertex))
--
-- >>> let (walk, binding) = runBinder binder
--
-- >>> toGremlin walk
-- "__.property(\"age\",__v0).identity()"
--
-- >>> sortBy (comparing fst) $ HashMap.toList binding
-- [("__v0",Number 21.0)]
--
writePropertyKeyValues :: (ToJSON v, Element e) => [(Text, v)] -> Binder (Walk SideEffect e e)
-- | Make a series of .property steps to write all properties in
-- the given PMap.
writePMapProperties :: (Foldable c, ToJSON v, Element e) => PMap c v -> Binder (Walk SideEffect e e)
-- | The result Walk emits the input elements as-is when there is at
-- least one input element. If there is no input element, it runs the
-- body traversal once and outputs its result.
--
-- You can use this function to implement "upsert" a vertex (i.e. add a
-- vertex if not exist).
--
--
-- >>> let getMarko = (source "g" & sV' [] &. gHas2 "name" "marko" :: GTraversal Transform () AVertex)
--
-- >>> let upsertMarko = (liftWalk getMarko &. gWhenEmptyInput (gAddV "person" >>> gProperty "name" "marko") :: GTraversal SideEffect () AVertex)
--
--
-- See also: https://stackoverflow.com/questions/46027444/
gWhenEmptyInput :: (ToGTraversal g, Split cc c, Lift Transform cc, Lift Transform c, WalkType c, WalkType cc) => g cc [s] s -> Walk c s s
-- | Data.Greskell is a Haskell support to use the Gremlin graph query
-- language. For more information, see project README.
--
-- This module re-exports most modules from greskell and greskell-core
-- packages. The following modules are excluded from re-export:
--
--
module Data.Greskell