tinkerpop-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From spmalle...@apache.org
Subject [tinkerpop] branch TINKERPOP-2002 updated: TINKERPOP-2002 Moved DSL specifics to each language variant
Date Fri, 09 Nov 2018 20:14:15 GMT
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-2002
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git


The following commit(s) were added to refs/heads/TINKERPOP-2002 by this push:
     new ec661c4  TINKERPOP-2002 Moved DSL specifics to each language variant
ec661c4 is described below

commit ec661c42195dd3f55843b40a048a1e7f0f9af4aa
Author: Stephen Mallette <spmva@genoprime.com>
AuthorDate: Fri Nov 9 15:13:48 2018 -0500

    TINKERPOP-2002 Moved DSL specifics to each language variant
---
 docs/src/reference/gremlin-variants.asciidoc | 291 ++++++++++++++++++++++++++
 docs/src/reference/the-traversal.asciidoc    | 294 +--------------------------
 2 files changed, 293 insertions(+), 292 deletions(-)

diff --git a/docs/src/reference/gremlin-variants.asciidoc b/docs/src/reference/gremlin-variants.asciidoc
index 0eb8885..d4074c6 100644
--- a/docs/src/reference/gremlin-variants.asciidoc
+++ b/docs/src/reference/gremlin-variants.asciidoc
@@ -418,6 +418,132 @@ g2Client.submit("g.V()")
 The above code demonstrates how the `alias` method can be used such that the script need
only contain a reference
 to "g" and "g1" and "g2" are automatically rebound into "g" on the server-side.
 
+[[gremlin-java-dsl]]
+=== Domain Specific Languages
+
+Creating a <<dsl,Domain Specific Language>> (DSL) in Java requires the `@GremlinDsl`
Java annotation in `gremlin-core`. This
+annotation should be applied to a "DSL interface" that extends `GraphTraversal.Admin`.
+
+[source,java]
+----
+@GremlinDsl
+public interface SocialTraversalDsl<S, E> extends GraphTraversal.Admin<S, E>
{
+}
+----
+
+IMPORTANT: The name of the DSL interface should be suffixed with "TraversalDSL". All characters
in the interface name
+before that become the "name" of the DSL.
+
+In this interface, define the methods that the DSL will be composed of:
+
+[source,java]
+----
+@GremlinDsl
+public interface SocialTraversalDsl<S, E> extends GraphTraversal.Admin<S, E>
{
+    public default GraphTraversal<S, Vertex> knows(String personName) {
+        return out("knows").hasLabel("person").has("name", personName);
+    }
+
+    public default <E2 extends Number> GraphTraversal<S, E2> youngestFriendsAge()
{
+        return out("knows").hasLabel("person").values("age").min();
+    }
+
+    public default GraphTraversal<S, Long> createdAtLeast(int number) {
+        return outE("created").count().is(P.gte(number));
+    }
+}
+----
+
+IMPORTANT: Follow the TinkerPop convention of using `<S,E>` in naming generics as those
conventions are taken into
+account when generating the anonymous traversal class. The processor attempts to infer the
appropriate type parameters
+when generating the anonymous traversal class. If it cannot do it correctly, it is possible
to avoid the inference by
+using the `GremlinDsl.AnonymousMethod` annotation on the DSL method. It allows explicit specification
of the types to
+use.
+
+The `@GremlinDsl` annotation is used by the link:https://docs.oracle.com/javase/8/docs/api/index.html?javax/annotation/processing/Processor.html[Java
Annotation Processor]
+to generate the boilerplate class structure required to properly use the DSL within the TinkerPop
framework. These
+classes can be generated and maintained by hand, but it would be time consuming, monotonous
and error-prone to do so.
+Typically, the Java compilation process is automatically configured to detect annotation
processors on the classpath
+and will automatically use them when found. If that does not happen, it may be necessary
to make configuration changes
+to the build to allow for the compilation process to be aware of the following `javax.annotation.processing.Processor`
+implementation:
+
+[source,java]
+----
+org.apache.tinkerpop.gremlin.process.traversal.dsl.GremlinDslProcessor
+----
+
+The annotation processor will generate several classes for the DSL:
+
+* `SocialTraversal` - A `Traversal` interface that extends the `SocialTraversalDsl` proxying
methods to its underlying
+interfaces (such as `GraphTraversal`) to instead return a `SocialTraversal`
+* `DefaultSocialTraversal` - A default implementation of `SocialTraversal` (typically not
used directly by the user)
+* `SocialTraversalSource` - Spawns `DefaultSocialTraversal` instances.
+* `__` - Spawns anonymous `DefaultSocialTraversal` instances.
+
+Using the DSL then just involves telling the `Graph` to use it:
+
+[source,java]
+----
+SocialTraversalSource social = graph.traversal(SocialTraversalSource.class);
+social.V().has("name","marko").knows("josh");
+----
+
+The `SocialTraversalSource` can also be customized with DSL functions. As an additional step,
include a class that
+extends from `GraphTraversalSource` and with a name that is suffixed with "TraversalSourceDsl".
Include in this class,
+any custom methods required by the DSL:
+
+[source,java]
+----
+public class SocialTraversalSourceDsl extends GraphTraversalSource {
+
+    public SocialTraversalSourceDsl(Graph graph, TraversalStrategies traversalStrategies)
{
+        super(graph, traversalStrategies);
+    }
+
+    public SocialTraversalSourceDsl(Graph graph) {
+        super(graph);
+    }
+
+    public GraphTraversal<Vertex, Vertex> persons(String... names) {
+        GraphTraversalSource clone = this.clone();
+
+        // Manually add a "start" step for the traversal in this case the equivalent of V().
GraphStep is marked
+        // as a "start" step by passing "true" in the constructor.
+        clone.getBytecode().addStep(GraphTraversal.Symbols.V);
+        GraphTraversal<Vertex, Vertex> traversal = new DefaultGraphTraversal<>(clone);
+        traversal.asAdmin().addStep(new GraphStep<>(traversal.asAdmin(), Vertex.class,
true));
+
+        traversal = traversal.hasLabel("person");
+        if (names.length > 0) traversal = traversal.has("name", P.within(names));
+
+        return traversal;
+    }
+}
+----
+
+Then, back in the `SocialTraversal` interface, update the `GremlinDsl` annotation with the
`traversalSource` argument
+to point to the fully qualified class name of the `SocialTraversalSourceDsl`:
+
+[source,java]
+----
+@GremlinDsl(traversalSource = "com.company.SocialTraversalSourceDsl")
+public interface SocialTraversalDsl<S, E> extends GraphTraversal.Admin<S, E>
{
+    ...
+}
+----
+
+It is then possible to use the `persons()` method to start traversals:
+
+[source,java]
+----
+SocialTraversalSource social = graph.traversal(SocialTraversalSource.class);
+social.persons("marko").knows("josh");
+----
+
+NOTE: Using Maven, as shown in the `gremlin-archetype-dsl` module, makes developing DSLs
with the annotation processor
+straightforward in that it sets up appropriate paths to the generated code automatically.
+
 [[gremlin-groovy]]
 == Gremlin-Groovy
 
@@ -736,6 +862,78 @@ returns a `concurrent.futures.Future` that resolves to a list when it
is complet
 <9> Verify that the all results have been read and stream is closed.
 <10> Close client and underlying pool connections.
 
+=== Domain Specific Languages
+
+Writing a Gremlin <<dsl,Domain Specific Language>> (DSL) in Python simply requires
direct extension of several classes:
+
+* `GraphTraversal` - which exposes the various steps used in traversal writing
+* `__` - which spawns anonymous traversals from steps
+* `GraphTraversalSource` - which spawns `GraphTraversal` instances
+
+The Social DSL based on the link:http://tinkerpop.apache.org/docs/current/images/tinkerpop-modern.png["modern"
toy graph]
+might look like this:
+
+[source,python]
+----
+class SocialTraversal(GraphTraversal):
+
+    def knows(self, person_name):
+        return self.out("knows").hasLabel("person").has("name", person_name)
+
+    def youngestFriendsAge(self):
+        return self.out("knows").hasLabel("person").values("age").min()
+
+    def createdAtLeast(self, number):
+        return self.outE("created").count().is_(P.gte(number))
+
+class __(AnonymousTraversal):
+
+    graph_traversal = SocialTraversal
+
+    @classmethod
+    def knows(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).knows(*args)
+
+    @classmethod
+    def youngestFriendsAge(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).youngestFriendsAge(*args)
+
+    @classmethod
+    def createdAtLeast(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).createdAtLeast(*args)
+
+
+class SocialTraversalSource(GraphTraversalSource):
+
+    def __init__(self, *args, **kwargs):
+        super(SocialTraversalSource, self).__init__(*args, **kwargs)
+        self.graph_traversal = SocialTraversal
+
+    def persons(self, *args):
+        traversal = self.get_graph_traversal()
+        traversal.bytecode.add_step("V")
+        traversal.bytecode.add_step("hasLabel", "person")
+
+        if len(args) > 0:
+            traversal.bytecode.add_step("has", "name", P.within(args))
+
+        return traversal
+----
+
+NOTE: The `AnonymousTraversal` class above is just an alias for `__` as in
+`from gremlin_python.process.graph_traversal import __ as AnonymousTraversal`
+
+Using the DSL is straightforward and just requires that the graph instance know the `SocialTraversalSource`
should
+be used:
+
+[source,python]
+----
+social = Graph().traversal(SocialTraversalSource).withRemote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
+social.persons("marko").knows("josh")
+social.persons("marko").youngestFriendsAge()
+social.persons().filter(__.createdAtLeast(2)).count()
+----
+
 [[gremlin-DotNet]]
 == Gremlin.Net
 
@@ -890,6 +1088,99 @@ g.V().Out().Map<int>(Lambda.Python("lambda x: len(x.get().value('name'))")).Sum<
 The `ILambda` interface returned by these two methods inherits interfaces like `IFunction`
and `IPredicate` that mirror
 their Java counterparts which makes it possible to use lambdas with Gremlin.Net for the same
steps as in Gremlin-Java.
 
+=== Domain Specific Languages
+
+Developing a <<dsl,Domain Specific Language>> (DSL) for .Net is most easily implemented
using
+link:https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods[Extension
Methods]
+as they don't require direct extension of classes in the TinkerPop hierarchy. Extension Method
classes simply need to
+be constructed for the `GraphTraversal` and the `GraphTraversalSource`. Unfortunately, anonymous
traversals (spawned
+from `__`) can't use the Extension Method approach as they do not work for static classes
and static classes can't be
+extended. The only option is to re-implement the methods of `__` as a wrapper in the anonymous
traversal for the DSL
+or to simply create a static class for the DSL and use the two anonymous traversals creators
independently. The
+following example uses the latter approach as it saves a lot of boilerplate code with the
minor annoyance of having a
+second static class to deal with when writing traversals rather than just calling `__` for
everything.
+
+[source,csharp]
+----
+namespace Dsl
+{
+
+    public static class SocialTraversalExtensions
+    {
+        public static GraphTraversal<Vertex,Vertex> Knows(this GraphTraversal<Vertex,Vertex>
t, string personName)
+        {
+            return t.Out("knows").HasLabel("person").Has("name", personName);
+        }
+
+        public static GraphTraversal<Vertex, int> YoungestFriendsAge(this GraphTraversal<Vertex,Vertex>
t)
+        {
+            return t.Out("knows").HasLabel("person").Values<int>("age").Min<int>();
+        }
+
+        public static GraphTraversal<Vertex,long> CreatedAtLeast(this GraphTraversal<Vertex,Vertex>
t, long number)
+        {
+            return t.OutE("created").Count().Is(P.Gte(number));
+        }
+    }
+
+    public static class __Social
+    {
+        public static GraphTraversal<object,Vertex> Knows(string personName)
+        {
+            return __.Out("knows").HasLabel("person").Has("name", personName);
+        }
+
+        public static GraphTraversal<object, int> YoungestFriendsAge()
+        {
+            return __.Out("knows").HasLabel("person").Values<int>("age").Min<int>();
+        }
+
+        public static GraphTraversal<object,long> CreatedAtLeast(long number)
+        {
+            return __.OutE("created").Count().Is(P.Gte(number));
+        }
+    }
+
+    public static class SocialTraversalSourceExtensions
+    {
+        public static GraphTraversal<Vertex,Vertex> Persons(this GraphTraversalSource
g, params string[] personNames)
+        {
+            GraphTraversal<Vertex,Vertex> t = g.V().HasLabel("person");
+
+            if (personNames.Length > 0)
+            {
+                t = t.Has("name", P.Within(personNames));
+            }
+
+            return t;
+        }
+    }
+}
+----
+
+Note the creation of `__Social` as the Social DSL's "extension" to the available ways in
which to spawn anonymous
+traversals. The use of the double underscore prefix in the name is just a convention to consider
using and is not a
+requirement. To use the DSL, bring it into scope with the `using` directive:
+
+[source,csharp]
+----
+using Dsl;
+using static Dsl.__Social;
+----
+
+and then it can be called from the application as follows:
+
+[source,csharp]
+----
+var graph = new Graph();
+var connection = new DriverRemoteConnection(new GremlinClient(new GremlinServer("localhost",
8182)));
+var social = graph.Traversal().WithRemote(connection);
+
+social.Persons("marko").Knows("josh");
+social.Persons("marko").YoungestFriendsAge();
+social.Persons().Filter(CreatedAtLeast(2)).Count();
+----
+
 [[gremlin-javascript]]
 == Gremlin-JavaScript
 
diff --git a/docs/src/reference/the-traversal.asciidoc b/docs/src/reference/the-traversal.asciidoc
index d2243d9..d46e072 100644
--- a/docs/src/reference/the-traversal.asciidoc
+++ b/docs/src/reference/the-traversal.asciidoc
@@ -3931,295 +3931,5 @@ g.V().hasLabel('person').has('name','marko').
 social.persons("marko").youngestFriendsAge()
 ----
 
-The following sections explain how to develop application specific DSLs for different <<gremlin-variants,Gremlin
Language Variants>>
-using the examples above of the Social DSL as the API for the implementation.
-
-[[gremlin-java-dsl]]
-=== Gremlin-Java
-
-Creating a DSL in Java requires the `@GremlinDsl` Java annotation in `gremlin-core`. This
annotation should be applied
-to a "DSL interface" that extends `GraphTraversal.Admin`.
-
-[source,java]
-----
-@GremlinDsl
-public interface SocialTraversalDsl<S, E> extends GraphTraversal.Admin<S, E>
{
-}
-----
-
-IMPORTANT: The name of the DSL interface should be suffixed with "TraversalDSL". All characters
in the interface name
-before that become the "name" of the DSL.
-
-In this interface, define the methods that the DSL will be composed of:
-
-[source,java]
-----
-@GremlinDsl
-public interface SocialTraversalDsl<S, E> extends GraphTraversal.Admin<S, E>
{
-    public default GraphTraversal<S, Vertex> knows(String personName) {
-        return out("knows").hasLabel("person").has("name", personName);
-    }
-
-    public default <E2 extends Number> GraphTraversal<S, E2> youngestFriendsAge()
{
-        return out("knows").hasLabel("person").values("age").min();
-    }
-
-    public default GraphTraversal<S, Long> createdAtLeast(int number) {
-        return outE("created").count().is(P.gte(number));
-    }
-}
-----
-
-IMPORTANT: Follow the TinkerPop convention of using `<S,E>` in naming generics as those
conventions are taken into
-account when generating the anonymous traversal class. The processor attempts to infer the
appropriate type parameters
-when generating the anonymous traversal class. If it cannot do it correctly, it is possible
to avoid the inference by
-using the `GremlinDsl.AnonymousMethod` annotation on the DSL method. It allows explicit specification
of the types to
-use.
-
-The `@GremlinDsl` annotation is used by the link:https://docs.oracle.com/javase/8/docs/api/index.html?javax/annotation/processing/Processor.html[Java
Annotation Processor]
-to generate the boilerplate class structure required to properly use the DSL within the TinkerPop
framework. These
-classes can be generated and maintained by hand, but it would be time consuming, monotonous
and error-prone to do so.
-Typically, the Java compilation process is automatically configured to detect annotation
processors on the classpath
-and will automatically use them when found. If that does not happen, it may be necessary
to make configuration changes
-to the build to allow for the compilation process to be aware of the following `javax.annotation.processing.Processor`
-implementation:
-
-[source,java]
-----
-org.apache.tinkerpop.gremlin.process.traversal.dsl.GremlinDslProcessor
-----
-
-The annotation processor will generate several classes for the DSL:
-
-* `SocialTraversal` - A `Traversal` interface that extends the `SocialTraversalDsl` proxying
methods to its underlying
-interfaces (such as `GraphTraversal`) to instead return a `SocialTraversal`
-* `DefaultSocialTraversal` - A default implementation of `SocialTraversal` (typically not
used directly by the user)
-* `SocialTraversalSource` - Spawns `DefaultSocialTraversal` instances.
-* `__` - Spawns anonymous `DefaultSocialTraversal` instances.
-
-Using the DSL then just involves telling the `Graph` to use it:
-
-[source,java]
-----
-SocialTraversalSource social = graph.traversal(SocialTraversalSource.class);
-social.V().has("name","marko").knows("josh");
-----
-
-The `SocialTraversalSource` can also be customized with DSL functions. As an additional step,
include a class that
-extends from `GraphTraversalSource` and with a name that is suffixed with "TraversalSourceDsl".
Include in this class,
-any custom methods required by the DSL:
-
-[source,java]
-----
-public class SocialTraversalSourceDsl extends GraphTraversalSource {
-
-    public SocialTraversalSourceDsl(Graph graph, TraversalStrategies traversalStrategies)
{
-        super(graph, traversalStrategies);
-    }
-
-    public SocialTraversalSourceDsl(Graph graph) {
-        super(graph);
-    }
-
-    public GraphTraversal<Vertex, Vertex> persons(String... names) {
-        GraphTraversalSource clone = this.clone();
-
-        // Manually add a "start" step for the traversal in this case the equivalent of V().
GraphStep is marked
-        // as a "start" step by passing "true" in the constructor.
-        clone.getBytecode().addStep(GraphTraversal.Symbols.V);
-        GraphTraversal<Vertex, Vertex> traversal = new DefaultGraphTraversal<>(clone);
-        traversal.asAdmin().addStep(new GraphStep<>(traversal.asAdmin(), Vertex.class,
true));
-
-        traversal = traversal.hasLabel("person");
-        if (names.length > 0) traversal = traversal.has("name", P.within(names));
-
-        return traversal;
-    }
-}
-----
-
-Then, back in the `SocialTraversal` interface, update the `GremlinDsl` annotation with the
`traversalSource` argument
-to point to the fully qualified class name of the `SocialTraversalSourceDsl`:
-
-[source,java]
-----
-@GremlinDsl(traversalSource = "com.company.SocialTraversalSourceDsl")
-public interface SocialTraversalDsl<S, E> extends GraphTraversal.Admin<S, E>
{
-    ...
-}
-----
-
-It is then possible to use the `persons()` method to start traversals:
-
-[source,java]
-----
-SocialTraversalSource social = graph.traversal(SocialTraversalSource.class);
-social.persons("marko").knows("josh");
-----
-
-NOTE: Using Maven, as shown in the `gremlin-archetype-dsl` module, makes developing DSLs
with the annotation processor
-straightforward in that it sets up appropriate paths to the generated code automatically.
-
-=== Gremlin-Python
-
-Writing a Gremlin DSL in Python simply requires direct extension of several classes:
-
-* `GraphTraversal` - which exposes the various steps used in traversal writing
-* `__` - which spawns anonymous traversals from steps
-* `GraphTraversalSource` - which spawns `GraphTraversal` instances
-
-The Social DSL based on the link:http://tinkerpop.apache.org/docs/current/images/tinkerpop-modern.png["modern"
toy graph]
-might look like this:
-
-[source,python]
-----
-class SocialTraversal(GraphTraversal):
-
-    def knows(self, person_name):
-        return self.out("knows").hasLabel("person").has("name", person_name)
-
-    def youngestFriendsAge(self):
-        return self.out("knows").hasLabel("person").values("age").min()
-
-    def createdAtLeast(self, number):
-        return self.outE("created").count().is_(P.gte(number))
-
-class __(AnonymousTraversal):
-
-    graph_traversal = SocialTraversal
-
-    @classmethod
-    def knows(cls, *args):
-        return cls.graph_traversal(None, None, Bytecode()).knows(*args)
-
-    @classmethod
-    def youngestFriendsAge(cls, *args):
-        return cls.graph_traversal(None, None, Bytecode()).youngestFriendsAge(*args)
-
-    @classmethod
-    def createdAtLeast(cls, *args):
-        return cls.graph_traversal(None, None, Bytecode()).createdAtLeast(*args)
-
-
-class SocialTraversalSource(GraphTraversalSource):
-
-    def __init__(self, *args, **kwargs):
-        super(SocialTraversalSource, self).__init__(*args, **kwargs)
-        self.graph_traversal = SocialTraversal
-
-    def persons(self, *args):
-        traversal = self.get_graph_traversal()
-        traversal.bytecode.add_step("V")
-        traversal.bytecode.add_step("hasLabel", "person")
-
-        if len(args) > 0:
-            traversal.bytecode.add_step("has", "name", P.within(args))
-
-        return traversal
-----
-
-NOTE: The `AnonymousTraversal` class above is just an alias for `__` as in
-`from gremlin_python.process.graph_traversal import __ as AnonymousTraversal`
-
-Using the DSL is straightforward and just requires that the graph instance know the `SocialTraversalSource`
should
-be used:
-
-[source,python]
-----
-social = Graph().traversal(SocialTraversalSource).withRemote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
-social.persons("marko").knows("josh")
-social.persons("marko").youngestFriendsAge()
-social.persons().filter(__.createdAtLeast(2)).count()
-----
-
-=== Gremlin.Net
-
-Developing DSLs for .Net is most easily implemented using link:https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods[Extension
Methods]
-as they don't require direct extension of classes in the TinkerPop hierarchy. Extension Method
classes simply need to
-be constructed for the `GraphTraversal` and the `GraphTraversalSource`. Unfortunately, anonymous
traversals (spawned
-from `__`) can't use the Extension Method approach as they do not work for static classes
and static classes can't be
-extended. The only option is to re-implement the methods of `__` as a wrapper in the anonymous
traversal for the DSL
-or to simply create a static class for the DSL and use the two anonymous traversals creators
independently. The
-following example uses the latter approach as it saves a lot of boilerplate code with the
minor annoyance of having a
-second static class to deal with when writing traversals rather than just calling `__` for
everything.
-
-[source,csharp]
-----
-namespace Dsl
-{
-
-    public static class SocialTraversalExtensions
-    {
-        public static GraphTraversal<Vertex,Vertex> Knows(this GraphTraversal<Vertex,Vertex>
t, string personName)
-        {
-            return t.Out("knows").HasLabel("person").Has("name", personName);
-        }
-
-        public static GraphTraversal<Vertex, int> YoungestFriendsAge(this GraphTraversal<Vertex,Vertex>
t)
-        {
-            return t.Out("knows").HasLabel("person").Values<int>("age").Min<int>();
-        }
-
-        public static GraphTraversal<Vertex,long> CreatedAtLeast(this GraphTraversal<Vertex,Vertex>
t, long number)
-        {
-            return t.OutE("created").Count().Is(P.Gte(number));
-        }
-    }
-
-    public static class __Social
-    {
-        public static GraphTraversal<object,Vertex> Knows(string personName)
-        {
-            return __.Out("knows").HasLabel("person").Has("name", personName);
-        }
-
-        public static GraphTraversal<object, int> YoungestFriendsAge()
-        {
-            return __.Out("knows").HasLabel("person").Values<int>("age").Min<int>();
-        }
-
-        public static GraphTraversal<object,long> CreatedAtLeast(long number)
-        {
-            return __.OutE("created").Count().Is(P.Gte(number));
-        }
-    }
-
-    public static class SocialTraversalSourceExtensions
-    {
-        public static GraphTraversal<Vertex,Vertex> Persons(this GraphTraversalSource
g, params string[] personNames)
-        {
-            GraphTraversal<Vertex,Vertex> t = g.V().HasLabel("person");
-
-            if (personNames.Length > 0)
-            {
-                t = t.Has("name", P.Within(personNames));
-            }
-
-            return t;
-        }
-    }
-}
-----
-
-Note the creation of `__Social` as the Social DSL's "extension" to the available ways in
which to spawn anonymous
-traversals. The use of the double underscore prefix in the name is just a convention to consider
using and is not a
-requirement. To use the DSL, bring it into scope with the `using` directive:
-
-[source,csharp]
-----
-using Dsl;
-using static Dsl.__Social;
-----
-
-and then it can be called from the application as follows:
-
-[source,csharp]
-----
-var graph = new Graph();
-var connection = new DriverRemoteConnection(new GremlinClient(new GremlinServer("localhost",
8182)));
-var social = graph.Traversal().WithRemote(connection);
-
-social.Persons("marko").Knows("josh");
-social.Persons("marko").YoungestFriendsAge();
-social.Persons().Filter(CreatedAtLeast(2)).Count();
-----
+Learn more about hwo to implement these DSLs in the <<gremlin-drivers-variants,Gremlin
Language Variants>> section
+specific to the programming language of interest.


Mime
View raw message