This is an automated email from the ASF dual-hosted git repository.

xiazcy pushed a commit to branch 3.7-aggregate-local
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 8ebde8bb34dee04f7453d7878730296a89cea260
Author: xiazcy <[email protected]>
AuthorDate: Tue Oct 7 08:52:37 2025 -0700

    Deprecated `AggregateLocalStep` and `aggregate(Scope, String)`. Added 
features tests for the preferred usage of `local(aggregate(String))`.
---
 CHANGELOG.asciidoc                                 |   1 +
 docs/src/upgrade/release-3.7.x.asciidoc            |  15 +
 .../traversal/dsl/graph/GraphTraversal.java        |   1 +
 .../gremlin/process/traversal/dsl/graph/__.java    |   1 +
 .../step/sideEffect/AggregateLocalStep.java        |   2 +
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs |  43 ++
 gremlin-go/driver/cucumber/gremlin.go              |  43 ++
 .../test/cucumber/feature-steps.js                 |   1 +
 .../gremlin-javascript/test/cucumber/gremlin.js    |  43 ++
 gremlin-python/src/main/python/radish/gremlin.py   |  43 ++
 .../test/features/sideEffect/Aggregate.feature     | 588 ++++++++++++++++++++-
 .../gremlin/test/features/sideEffect/Store.feature |  53 ++
 12 files changed, 811 insertions(+), 23 deletions(-)

diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 671a28664c..c534e92023 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -24,6 +24,7 @@ 
image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
 === TinkerPop 3.7.5 (Release Date: NOT OFFICIALLY RELEASED YET)
 
 * Improved Java driver host availability on connection pool initialization.
+* Deprecate `AggregateLocalStep` and `aggregate(Scope, String)`.
 * Added getter for `parameterItems` and `valueTraversal` on `DifferenceStep`.
 * Added properties to `Element` objects found in a `Path` for GraphSON v2 and 
v3 and GraphBinary.
 * Fixed edge properties for GraphBinary which were not deserializing properly.
diff --git a/docs/src/upgrade/release-3.7.x.asciidoc 
b/docs/src/upgrade/release-3.7.x.asciidoc
index 09d40562ac..843ea32b8b 100644
--- a/docs/src/upgrade/release-3.7.x.asciidoc
+++ b/docs/src/upgrade/release-3.7.x.asciidoc
@@ -30,6 +30,21 @@ complete list of all the modifications that are part of this 
release.
 
 === Upgrading for Users
 
+==== Deprecation of Scopes in aggregate() Step
+
+Scopes are now deprecated inside the `aggregate()` step, and will be removed 
in the next major upgrade.
+The preferred way to achieve lazy evaluation with `aggregate()`, is using 
`local()`.
+
+[source,text]
+----
+// 3.7.4
+gremlin> g.V().aggregate(Scope.local, "x").by("age").cap("x")
+==>[29,27,32,35]
+
+// 3.7.5 convention
+gremlin> g.V().local(aggregate("x").by("age")).cap("x")
+==>[29,27,32,35]
+----
 
 === Upgrading for Providers
 
diff --git 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
index c97a172b6d..a790fe1b30 100644
--- 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
+++ 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
@@ -2920,6 +2920,7 @@ public interface GraphTraversal<S, E> extends 
Traversal<S, E> {
      * @return the traversal with an appended {@link AggregateGlobalStep}
      * @see <a 
href="http://tinkerpop.apache.org/docs/${project.version}/reference/#aggregate-step";
 target="_blank">Reference Documentation - Aggregate Step</a>
      * @since 3.4.3
+     * @deprecated As of release 3.7.5, aggregate() is no longer scoped, to 
achieve lazy evaluation use aggregate() inside of local()
      */
     public default GraphTraversal<S, E> aggregate(final Scope scope, final 
String sideEffectKey) {
         this.asAdmin().getBytecode().addStep(Symbols.aggregate, scope, 
sideEffectKey);
diff --git 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
index 270317772c..8d3e3af1bf 100644
--- 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
+++ 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
@@ -1235,6 +1235,7 @@ public class __ {
 
     /**
      * @see GraphTraversal#aggregate(Scope, String)
+     * @deprecated As of release 3.7.5, aggregate() is no longer scoped, to 
achieve lazy evaluation use local() with aggregate() instead
      */
     public static <A> GraphTraversal<A, A> aggregate(final Scope scope, final 
String sideEffectKey) {
         return __.<A>start().aggregate(scope, sideEffectKey);
diff --git 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AggregateLocalStep.java
 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AggregateLocalStep.java
index 89970f55e0..91a22ad778 100644
--- 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AggregateLocalStep.java
+++ 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AggregateLocalStep.java
@@ -39,7 +39,9 @@ import java.util.function.Supplier;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
+ * @deprecated As of release 3.7.5, use local() with aggregate() instead
  */
+@Deprecated
 public final class AggregateLocalStep<S> extends SideEffectStep<S> implements 
SideEffectCapable<Collection, Collection>, TraversalParent, ByModulating {
 
     private Traversal.Admin<S, Object> storeTraversal = null;
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs 
b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index 289228fe00..40e3fb2cc9 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -1448,11 +1448,17 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                
{"g_V_hasLabelXpersonX_aggregateXxX_byXageX_capXxX_asXyX_selectXyX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("person").Aggregate("x").By("age").Cap<object>("x").As("y").Select<object>("y")}},
 
                {"g_V_aggregateXxX_byXageX_capXxX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.V().Aggregate("x").By("age").Cap<object>("x")}}, 
                {"g_V_aggregateXlocal_xX_byXageX_capXxX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.V().Aggregate(Scope.Local,"x").By("age").Cap<object>("x")}}, 
+               {"g_V_localXaggregateXxX_byXageXX_capXxX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.V().Local<object>(__.Aggregate("x").By("age")).Cap<object>("x")}}, 
                
{"g_withStrategiesXProductiveByStrategyX_V_aggregateXlocal_xX_byXageX_capXxX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new ProductiveByStrategy(productiveKeys: new 
List<object> {})).V().Aggregate(Scope.Local,"x").By("age").Cap<object>("x")}}, 
+               
{"g_withStrategiesXProductiveByStrategyX_V_localXaggregateXxX_byXageXX_capXxX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new ProductiveByStrategy(productiveKeys: new 
List<object> 
{})).V().Local<object>(__.Aggregate("x").By("age")).Cap<object>("x")}}, 
                {"g_V_aggregateXlocal_a_nameX_out_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.V().Aggregate(Scope.Local,"a").By("name").Out().Cap<object>("a")}}, 
+               {"g_V_localX_aggregateXa_byXnameXX_out_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a").By("name")).Out().Cap<object>("a")}}, 
                
{"g_VX1X_aggregateXlocal_aX_byXnameX_out_aggregateXlocal_aX_byXnameX_name_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V(p["vid1"]).Aggregate(Scope.Local,"a").By("name").Out().Aggregate(Scope.Local,"a").By("name").Values<object>("name").Cap<object>("a")}},
 
+               
{"g_VX1X_localXaggregateXaX_byXnameXX_out_localXaggregateXaX_byXnameXX_name_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V(p["vid1"]).Local<object>(__.Aggregate("a").By("name")).Out().Local<object>(__.Aggregate("a").By("name")).Values<object>("name").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",p["xx1"]).V().Both().Values<object>("name").Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_setX_V_both_name_localXaggregateX_aXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",p["xx1"]).V().Both().Values<object>("name").Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
                
{"g_V_aggregateXlocal_aX_byXoutEXcreatedX_countX_out_out_aggregateXlocal_aX_byXinEXcreatedX_weight_sumX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate(Scope.Local,"a").By(__.OutE("created").Count()).Out().Out().Aggregate(Scope.Local,"a").By(__.InE("created").Values<object>("weight").Sum<object>()).Cap<object>("a")}},
 
+               
{"g_V_localXaggregateXaX_byXoutEXcreatedX_countXX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a").By(__.OutE("created").Count())).Out().Out().Local<object>(__.Aggregate("a").By(__.InE("created").Values<object>("weight").Sum<object>())).Cap<object>("a")}},
 
                {"g_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate("x").By(__.Values<object>("age").Is(P.Gt(29))).Cap<object>("x")}},
 
                
{"g_withStrategiesXProductiveByStrategyX_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new ProductiveByStrategy(productiveKeys: new 
List<object> 
{})).V().Aggregate("x").By(__.Values<object>("age").Is(P.Gt(29))).Cap<object>("x")}},
 
                {"g_V_aggregateXxX_byXout_order_byXnameXX_capXxX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate("x").By(__.Out().Order().By("name")).Cap<object>("x")}}, 
@@ -1460,28 +1466,62 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                
{"g_V_aggregateXaX_hasXperson_age_gteX30XXX_capXaX_unfold_valuesXnameX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate("a").Has("person","age",P.Gte(30)).Cap<object>("a").Unfold<object>().Values<object>("name")}},
 
                {"g_withSideEffectXa_1_sumX_V_aggregateXaX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Sum).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_1_sumX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Sum).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_1_sumX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Sum).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                {"g_withSideEffectXa_123_minusX_V_aggregateXaX_byXageX_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",123,Operator.Minus).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_123_minusX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",123,Operator.Minus).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_123_minusX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",123,Operator.Minus).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                {"g_withSideEffectXa_2_multX_V_aggregateXaX_byXageX_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",2,Operator.Mult).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_2_multX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",2,Operator.Mult).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_2_multX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",2,Operator.Mult).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                
{"g_withSideEffectXa_876960_divX_V_aggregateXaX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",876960,Operator.Div).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_876960_divX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",876960,Operator.Div).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_876960_divX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",876960,Operator.Div).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                {"g_withSideEffectXa_1_minX_V_aggregateXaX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Min).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_1_minX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Min).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_1_minX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Min).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                {"g_withSideEffectXa_100_minX_V_aggregateXaX_byXageX_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",100,Operator.Min).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_100_minX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",100,Operator.Min).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_100_minX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",100,Operator.Min).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                {"g_withSideEffectXa_1_maxX_V_aggregateXaX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Max).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_1_maxX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Max).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_1_maxX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",1,Operator.Max).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                {"g_withSideEffectXa_100_maxX_V_aggregateXaX_byXageX_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",100,Operator.Max).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_100_maxX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",100,Operator.Max).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_100_maxX_V_localXaggregateX_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",100,Operator.Max).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                
{"g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXaX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",true,Operator.And).V().Constant<object>(false).Aggregate("a").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXlocal_aX_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",true,Operator.And).V().Constant<object>(false).Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_true_andX_V_constantXfalseX_localXaggregateX_aXX_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",true,Operator.And).V().Constant<object>(false).Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
                
{"g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXaX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",true,Operator.Or).V().Constant<object>(false).Aggregate("a").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXlocal_aX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",true,Operator.Or).V().Constant<object>(false).Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_true_orX_V_constantXfalseX_localXaggregateX_aXX_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",true,Operator.Or).V().Constant<object>(false).Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
                
{"g_withSideEffectXa_xx1_addAllX_V_aggregateXaX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",p["xx1"],Operator.AddAll).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_xx1_addAllX_V_aggregateXlocal_aX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",p["xx1"],Operator.AddAll).V().Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_1_2_3_addAllX_V_localXaggregateX_aX_byXageXX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithSideEffect("a",new List<object> {1, 2, 
3},Operator.AddAll).V().Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
                
{"g_withSideEffectXa_xx1_assignX_V_aggregateXaX_byXageX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",p["xx1"],Operator.Assign).V().Aggregate("a").By("age").Cap<object>("a")}},
 
                
{"g_withSideEffectXa_xx1_assignX_V_order_byXageX_aggregateXlocal_aX_byXageX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",p["xx1"],Operator.Assign).V().Order().By("age").Aggregate(Scope.Local,"a").By("age").Cap<object>("a")}},
 
+               
{"g_withSideEffectXa_1_2_3_assignX_V_order_byXageX_localXaggregateX_aX_byXageXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithSideEffect("a",new List<object> {1, 2, 
3},Operator.Assign).V().Order().By("age").Local<object>(__.Aggregate("a").By("age")).Cap<object>("a")}},
 
+               
{"g_V_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX_unfold_dedup", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a")).OutE().InV().Local<object>(__.Aggregate("a")).Cap<object>("a").Unfold<object>().Dedup()}},
 
+               
{"g_V_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX_unfold_dedup", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate(Scope.Local,"a").OutE().InV().Aggregate(Scope.Local,"a").Cap<object>("a").Unfold<object>().Dedup()}},
 
+               
{"g_V_hasLabelXpersonX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("person").Local<object>(__.Aggregate("a")).Out("created").Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
+               
{"g_V_hasLabelXpersonX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("person").Aggregate(Scope.Local,"a").Out("created").Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
+               
{"g_V_localXaggregateXaXX_repeatXout_localXaggregateXaXXX_timesX2X_capXaX_unfold_groupCount",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a")).Repeat(__.Out().Local<object>(__.Aggregate("a"))).Times(2).Cap<object>("a").Unfold<object>().Values<object>("name").GroupCount<object>()}},
 
+               
{"g_V_aggregateXlocal_aX_repeatXout_aggregateXlocal_aXX_timesX2X_capXaX_unfold_groupCount",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate(Scope.Local,"a").Repeat(__.Out().Aggregate(Scope.Local,"a")).Times(2).Cap<object>("a").Unfold<object>().Values<object>("name").GroupCount<object>()}},
 
+               
{"g_V_hasXname_markoX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Has("name","marko").Local<object>(__.Aggregate("a")).Out("knows").Local<object>(__.Aggregate("a")).Out("created").Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
+               
{"g_V_hasXname_markoX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Has("name","marko").Aggregate(Scope.Local,"a").Out("knows").Aggregate(Scope.Local,"a").Out("created").Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
+               
{"g_V_hasLabelXsoftwareX_localXaggregateXaXX_inXcreatedX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("software").Local<object>(__.Aggregate("a")).In("created").Local<object>(__.Aggregate("a")).Out("knows").Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
+               
{"g_V_hasLabelXsoftwareX_aggregateXlocal_aX_inXcreatedX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("software").Aggregate(Scope.Local,"a").In("created").Aggregate(Scope.Local,"a").Out("knows").Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
+               
{"g_V_localXaggregateXaXX_outE_hasXweight_lgtX0_5XX_inV_localXaggregateXaXX_capXaX_unfold_path",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a")).OutE().Has("weight",P.Gt(0.5)).InV().Local<object>(__.Aggregate("a")).Cap<object>("a").Unfold<object>().Path()}},
 
+               
{"g_V_aggregateXlocal_aX_outE_hasXweight_lgtX0_5XX_inV_aggregateXlocal_aX_capXaX_unfold_path",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate(Scope.Local,"a").OutE().Has("weight",P.Gt(0.5)).InV().Aggregate(Scope.Local,"a").Cap<object>("a").Unfold<object>().Path()}},
 
+               
{"g_V_localXaggregateXaXX_bothE_sampleX1X_otherV_localXaggregateXaXX_capXaX_unfold_groupCount_byXlabelX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a")).BothE().Sample(1).OtherV().Local<object>(__.Aggregate("a")).Cap<object>("a").Unfold<object>().GroupCount<object>().By(T.Label)}},
 
+               
{"g_V_aggregateXlocal_aX_bothE_sampleX1X_otherV_aggregateXlocal_aX_capXaX_unfold_groupCount_byXlabelX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate(Scope.Local,"a").BothE().Sample(1).OtherV().Aggregate(Scope.Local,"a").Cap<object>("a").Unfold<object>().GroupCount<object>().By(T.Label)}},
 
+               
{"g_V_hasLabelXpersonX_localXaggregateXaXX_outE_inV_simplePath_localXaggregateXaXX_capXaX_unfold_hasLabelXsoftwareX_count",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("person").Local<object>(__.Aggregate("a")).OutE().InV().SimplePath().Local<object>(__.Aggregate("a")).Cap<object>("a").Unfold<object>().HasLabel("software").Count()}},
 
+               
{"g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_inV_simplePath_aggregateXlocal_aX_capXaX_unfold_hasLabelXsoftwareX_count",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("person").Aggregate(Scope.Local,"a").OutE().InV().SimplePath().Aggregate(Scope.Local,"a").Cap<object>("a").Unfold<object>().HasLabel("software").Count()}},
 
+               
{"g_V_localXaggregateXaXX_unionXout_inX_localXaggregateXaXX_capXaX_unfold_dedup_valuesXnameX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a")).Union<object>(__.Out(),__.In()).Local<object>(__.Aggregate("a")).Cap<object>("a").Unfold<object>().Dedup().Values<object>("name")}},
 
+               
{"g_V_aggregateXlocal_aX_unionXout_inX_aggregateXlocal_aX_capXaX_unfold_dedup_valuesXnameX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Aggregate(Scope.Local,"a").Union<object>(__.Out(),__.In()).Aggregate(Scope.Local,"a").Cap<object>("a").Unfold<object>().Dedup().Values<object>("name")}},
 
+               
{"g_V_hasXname_joshX_localXaggregateXaXX_outE_hasXweight_ltX1_0XX_inV_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Has("name","josh").Local<object>(__.Aggregate("a")).OutE().Has("weight",P.Lt(1.0)).InV().Local<object>(__.Aggregate("a")).OutE().InV().Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
+               
{"g_V_hasXname_joshX_aggregateXlocal_aX_outE_hasXweight_ltX1_0XX_inV_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Has("name","josh").Aggregate(Scope.Local,"a").OutE().Has("weight",P.Lt(1.0)).InV().Aggregate(Scope.Local,"a").OutE().InV().Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
+               
{"g_V_hasLabelXpersonX_localXaggregateXaXX_outE_order_byXweightX_limitX1X_inV_localXaggregateXaXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("person").Local<object>(__.Aggregate("a")).OutE().Order().By("weight").Limit<object>(1).InV().Local<object>(__.Aggregate("a")).Cap<object>("a")}},
 
+               
{"g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_order_byXweightX_limitX1X_inV_aggregateXlocal_aX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().HasLabel("person").Aggregate(Scope.Local,"a").OutE().Order().By("weight").Limit<object>(1).InV().Aggregate(Scope.Local,"a").Cap<object>("a")}},
 
                {"g_V_fail", new List<Func<GraphTraversalSource, 
IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fail()}}, 
                {"g_V_failXmsgX", new List<Func<GraphTraversalSource, 
IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fail("msg")}}, 
                {"g_V_unionXout_failX", new List<Func<GraphTraversalSource, 
IDictionary<string, object>, ITraversal>> {(g,p) 
=>g.V().Union<object>(__.Out(),__.Fail())}}, 
@@ -1556,9 +1596,12 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Group("m").By("name").By(__.In("knows").Values<object>("name")).Cap<object>("m")}},
 
                {"g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Group("m").By(__.Label()).By(__.Label().Count()).Cap<object>("m")}}, 
                {"g_V_storeXa_nameX_out_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.V().Store("a").By("name").Out().Cap<object>("a")}}, 
+               {"g_V_localXaggregateXa_nameXX_out_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a").By("name")).Out().Cap<object>("a")}}, 
                {"g_VX1X_storeXaX_byXnameX_out_storeXaX_byXnameX_name_capXaX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V(p["vid1"]).Store("a").By("name").Out().Store("a").By("name").Values<object>("name").Cap<object>("a")}},
 
+               
{"g_VX1X_storeXaX_byXnameX_out_localXaggregateXaX_byXnameXX_name_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V(p["vid1"]).Store("a").By("name").Out().Local<object>(__.Aggregate("a").By("name")).Values<object>("name").Cap<object>("a")}},
 
                {"g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithSideEffect("a",p["xx1"]).V().Both().Values<object>("name").Store("a").Cap<object>("a")}},
 
                
{"g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Store("a").By(__.OutE("created").Count()).Out().Out().Store("a").By(__.InE("created").Values<object>("weight").Sum<object>()).Cap<object>("a")}},
 
+               
{"g_V_localXaggregateXaX_byXoutEXcreatedX_countX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.V().Local<object>(__.Aggregate("a").By(__.OutE("created").Count())).Out().Out().Local<object>(__.Aggregate("a").By(__.InE("created").Values<object>("weight").Sum<object>())).Cap<object>("a")}},
 
             };
 
         public static ITraversal UseTraversal(string scenarioName, 
GraphTraversalSource g, IDictionary<string, object> parameters)
diff --git a/gremlin-go/driver/cucumber/gremlin.go 
b/gremlin-go/driver/cucumber/gremlin.go
index 1ce169f7f5..3399c28560 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -1419,11 +1419,17 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     "g_V_hasLabelXpersonX_aggregateXxX_byXageX_capXxX_asXyX_selectXyX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Aggregate("x").By("age").Cap("x").As("y").Select("y")}},
 
     "g_V_aggregateXxX_byXageX_capXxX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate("x").By("age").Cap("x")}}, 
     "g_V_aggregateXlocal_xX_byXageX_capXxX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"x").By("age").Cap("x")}}, 
+    "g_V_localXaggregateXxX_byXageXX_capXxX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("x").By("age")).Cap("x")}}, 
     
"g_withStrategiesXProductiveByStrategyX_V_aggregateXlocal_xX_byXageX_capXxX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ProductiveByStrategy(gremlingo.ProductiveByStrategyConfig{ProductiveKeys:
 []string{}})).V().Aggregate(gremlingo.Scope.Local, "x").By("age").Cap("x")}}, 
+    
"g_withStrategiesXProductiveByStrategyX_V_localXaggregateXxX_byXageXX_capXxX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ProductiveByStrategy(gremlingo.ProductiveByStrategyConfig{ProductiveKeys:
 []string{}})).V().Local(gremlingo.T__.Aggregate("x").By("age")).Cap("x")}}, 
     "g_V_aggregateXlocal_a_nameX_out_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"a").By("name").Out().Cap("a")}}, 
+    "g_V_localX_aggregateXa_byXnameXX_out_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a").By("name")).Out().Cap("a")}}, 
     
"g_VX1X_aggregateXlocal_aX_byXnameX_out_aggregateXlocal_aX_byXnameX_name_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V(p["vid1"]).Aggregate(gremlingo.Scope.Local, 
"a").By("name").Out().Aggregate(gremlingo.Scope.Local, 
"a").By("name").Values("name").Cap("a")}}, 
+    
"g_VX1X_localXaggregateXaX_byXnameXX_out_localXaggregateXaX_byXnameXX_name_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V(p["vid1"]).Local(gremlingo.T__.Aggregate("a").By("name")).Out().Local(gremlingo.T__.Aggregate("a").By("name")).Values("name").Cap("a")}},
 
     "g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 
p["xx1"]).V().Both().Values("name").Aggregate(gremlingo.Scope.Local, 
"a").Cap("a")}}, 
+    "g_withSideEffectXa_setX_V_both_name_localXaggregateX_aXX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 
p["xx1"]).V().Both().Values("name").Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
     
"g_V_aggregateXlocal_aX_byXoutEXcreatedX_countX_out_out_aggregateXlocal_aX_byXinEXcreatedX_weight_sumX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"a").By(gremlingo.T__.OutE("created").Count()).Out().Out().Aggregate(gremlingo.Scope.Local,
 "a").By(gremlingo.T__.InE("created").Values("weight").Sum()).Cap("a")}}, 
+    
"g_V_localXaggregateXaX_byXoutEXcreatedX_countXX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a").By(gremlingo.T__.OutE("created").Count())).Out().Out().Local(gremlingo.T__.Aggregate("a").By(gremlingo.T__.InE("created").Values("weight").Sum())).Cap("a")}},
 
     "g_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Aggregate("x").By(gremlingo.T__.Values("age").Is(gremlingo.P.Gt(29))).Cap("x")}},
 
     
"g_withStrategiesXProductiveByStrategyX_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ProductiveByStrategy(gremlingo.ProductiveByStrategyConfig{ProductiveKeys:
 
[]string{}})).V().Aggregate("x").By(gremlingo.T__.Values("age").Is(gremlingo.P.Gt(29))).Cap("x")}},
 
     "g_V_aggregateXxX_byXout_order_byXnameXX_capXxX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Aggregate("x").By(gremlingo.T__.Out().Order().By("name")).Cap("x")}}, 
@@ -1431,28 +1437,62 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     "g_V_aggregateXaX_hasXperson_age_gteX30XXX_capXaX_unfold_valuesXnameX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate("a").Has("person", "age", 
gremlingo.P.Gte(30)).Cap("a").Unfold().Values("name")}}, 
     "g_withSideEffectXa_1_sumX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Sum).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_1_sumX_V_aggregateXlocal_aX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Sum).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_1_sumX_V_localXaggregateX_aX_byXageXX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Sum).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_123_minusX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 123, 
gremlingo.Operator.Minus).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_123_minusX_V_aggregateXlocal_aX_byXageX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 123, 
gremlingo.Operator.Minus).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_123_minusX_V_localXaggregateX_aX_byXageXX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 123, 
gremlingo.Operator.Minus).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_2_multX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 2, 
gremlingo.Operator.Mult).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_2_multX_V_aggregateXlocal_aX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 2, 
gremlingo.Operator.Mult).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_2_multX_V_localXaggregateX_aX_byXageXX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 2, 
gremlingo.Operator.Mult).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_876960_divX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 876960, 
gremlingo.Operator.Div).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_876960_divX_V_aggregateXlocal_aX_byXageX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 876960, 
gremlingo.Operator.Div).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_876960_divX_V_localXaggregateX_aX_byXageXX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 876960, 
gremlingo.Operator.Div).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_1_minX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Min).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_1_minX_V_aggregateXlocal_aX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Min).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_1_minX_V_localXaggregateX_aX_byXageXX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Min).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_100_minX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 100, 
gremlingo.Operator.Min).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_100_minX_V_aggregateXlocal_aX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 100, 
gremlingo.Operator.Min).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_100_minX_V_localXaggregateX_aX_byXageXX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 100, 
gremlingo.Operator.Min).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_1_maxX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Max).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_1_maxX_V_aggregateXlocal_aX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Max).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_1_maxX_V_localXaggregateX_aX_byXageXX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 1, 
gremlingo.Operator.Max).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_100_maxX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 100, 
gremlingo.Operator.Max).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_100_maxX_V_aggregateXlocal_aX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 100, 
gremlingo.Operator.Max).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_100_maxX_V_localXaggregateX_aX_byXageX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 100, 
gremlingo.Operator.Max).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXaX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", true, 
gremlingo.Operator.And).V().Constant(false).Aggregate("a").Cap("a")}}, 
     
"g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXlocal_aX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", true, 
gremlingo.Operator.And).V().Constant(false).Aggregate(gremlingo.Scope.Local, 
"a").Cap("a")}}, 
+    
"g_withSideEffectXa_true_andX_V_constantXfalseX_localXaggregateX_aXX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", true, 
gremlingo.Operator.And).V().Constant(false).Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
     "g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXaX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", true, 
gremlingo.Operator.Or).V().Constant(false).Aggregate("a").Cap("a")}}, 
     "g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXlocal_aX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", true, 
gremlingo.Operator.Or).V().Constant(false).Aggregate(gremlingo.Scope.Local, 
"a").Cap("a")}}, 
+    
"g_withSideEffectXa_true_orX_V_constantXfalseX_localXaggregateX_aXX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", true, 
gremlingo.Operator.Or).V().Constant(false).Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
     "g_withSideEffectXa_xx1_addAllX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", p["xx1"], 
gremlingo.Operator.AddAll).V().Aggregate("a").By("age").Cap("a")}}, 
     "g_withSideEffectXa_xx1_addAllX_V_aggregateXlocal_aX_byXageX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", p["xx1"], 
gremlingo.Operator.AddAll).V().Aggregate(gremlingo.Scope.Local, 
"a").By("age").Cap("a")}}, 
+    "g_withSideEffectXa_1_2_3_addAllX_V_localXaggregateX_aX_byXageXX_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", []interface{}{1, 2, 3}, 
gremlingo.Operator.AddAll).V().Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
     "g_withSideEffectXa_xx1_assignX_V_aggregateXaX_byXageX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", p["xx1"], 
gremlingo.Operator.Assign).V().Aggregate("a").By("age").Cap("a")}}, 
     
"g_withSideEffectXa_xx1_assignX_V_order_byXageX_aggregateXlocal_aX_byXageX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", p["xx1"], 
gremlingo.Operator.Assign).V().Order().By("age").Aggregate(gremlingo.Scope.Local,
 "a").By("age").Cap("a")}}, 
+    
"g_withSideEffectXa_1_2_3_assignX_V_order_byXageX_localXaggregateX_aX_byXageXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", []interface{}{1, 2, 3}, 
gremlingo.Operator.Assign).V().Order().By("age").Local(gremlingo.T__.Aggregate("a").By("age")).Cap("a")}},
 
+    
"g_V_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX_unfold_dedup": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a")).OutE().InV().Local(gremlingo.T__.Aggregate("a")).Cap("a").Unfold().Dedup()}},
 
+    "g_V_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX_unfold_dedup": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"a").OutE().InV().Aggregate(gremlingo.Scope.Local, 
"a").Cap("a").Unfold().Dedup()}}, 
+    
"g_V_hasLabelXpersonX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Local(gremlingo.T__.Aggregate("a")).Out("created").Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
+    
"g_V_hasLabelXpersonX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Aggregate(gremlingo.Scope.Local, 
"a").Out("created").Aggregate(gremlingo.Scope.Local, "a").Cap("a")}}, 
+    
"g_V_localXaggregateXaXX_repeatXout_localXaggregateXaXXX_timesX2X_capXaX_unfold_groupCount":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a")).Repeat(gremlingo.T__.Out().Local(gremlingo.T__.Aggregate("a"))).Times(2).Cap("a").Unfold().Values("name").GroupCount()}},
 
+    
"g_V_aggregateXlocal_aX_repeatXout_aggregateXlocal_aXX_timesX2X_capXaX_unfold_groupCount":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"a").Repeat(gremlingo.T__.Out().Aggregate(gremlingo.Scope.Local, 
"a")).Times(2).Cap("a").Unfold().Values("name").GroupCount()}}, 
+    
"g_V_hasXname_markoX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Has("name", 
"marko").Local(gremlingo.T__.Aggregate("a")).Out("knows").Local(gremlingo.T__.Aggregate("a")).Out("created").Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
+    
"g_V_hasXname_markoX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Has("name", 
"marko").Aggregate(gremlingo.Scope.Local, 
"a").Out("knows").Aggregate(gremlingo.Scope.Local, 
"a").Out("created").Aggregate(gremlingo.Scope.Local, "a").Cap("a")}}, 
+    
"g_V_hasLabelXsoftwareX_localXaggregateXaXX_inXcreatedX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("software").Local(gremlingo.T__.Aggregate("a")).In("created").Local(gremlingo.T__.Aggregate("a")).Out("knows").Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
+    
"g_V_hasLabelXsoftwareX_aggregateXlocal_aX_inXcreatedX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("software").Aggregate(gremlingo.Scope.Local, 
"a").In("created").Aggregate(gremlingo.Scope.Local, 
"a").Out("knows").Aggregate(gremlingo.Scope.Local, "a").Cap("a")}}, 
+    
"g_V_localXaggregateXaXX_outE_hasXweight_lgtX0_5XX_inV_localXaggregateXaXX_capXaX_unfold_path":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a")).OutE().Has("weight", 
gremlingo.P.Gt(0.5)).InV().Local(gremlingo.T__.Aggregate("a")).Cap("a").Unfold().Path()}},
 
+    
"g_V_aggregateXlocal_aX_outE_hasXweight_lgtX0_5XX_inV_aggregateXlocal_aX_capXaX_unfold_path":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"a").OutE().Has("weight", 
gremlingo.P.Gt(0.5)).InV().Aggregate(gremlingo.Scope.Local, 
"a").Cap("a").Unfold().Path()}}, 
+    
"g_V_localXaggregateXaXX_bothE_sampleX1X_otherV_localXaggregateXaXX_capXaX_unfold_groupCount_byXlabelX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a")).BothE().Sample(1).OtherV().Local(gremlingo.T__.Aggregate("a")).Cap("a").Unfold().GroupCount().By(gremlingo.T.Label)}},
 
+    
"g_V_aggregateXlocal_aX_bothE_sampleX1X_otherV_aggregateXlocal_aX_capXaX_unfold_groupCount_byXlabelX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"a").BothE().Sample(1).OtherV().Aggregate(gremlingo.Scope.Local, 
"a").Cap("a").Unfold().GroupCount().By(gremlingo.T.Label)}}, 
+    
"g_V_hasLabelXpersonX_localXaggregateXaXX_outE_inV_simplePath_localXaggregateXaXX_capXaX_unfold_hasLabelXsoftwareX_count":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Local(gremlingo.T__.Aggregate("a")).OutE().InV().SimplePath().Local(gremlingo.T__.Aggregate("a")).Cap("a").Unfold().HasLabel("software").Count()}},
 
+    
"g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_inV_simplePath_aggregateXlocal_aX_capXaX_unfold_hasLabelXsoftwareX_count":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Aggregate(gremlingo.Scope.Local, 
"a").OutE().InV().SimplePath().Aggregate(gremlingo.Scope.Local, 
"a").Cap("a").Unfold().HasLabel("software").Count()}}, 
+    
"g_V_localXaggregateXaXX_unionXout_inX_localXaggregateXaXX_capXaX_unfold_dedup_valuesXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a")).Union(gremlingo.T__.Out(), 
gremlingo.T__.In()).Local(gremlingo.T__.Aggregate("a")).Cap("a").Unfold().Dedup().Values("name")}},
 
+    
"g_V_aggregateXlocal_aX_unionXout_inX_aggregateXlocal_aX_capXaX_unfold_dedup_valuesXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Aggregate(gremlingo.Scope.Local, 
"a").Union(gremlingo.T__.Out(), 
gremlingo.T__.In()).Aggregate(gremlingo.Scope.Local, 
"a").Cap("a").Unfold().Dedup().Values("name")}}, 
+    
"g_V_hasXname_joshX_localXaggregateXaXX_outE_hasXweight_ltX1_0XX_inV_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Has("name", 
"josh").Local(gremlingo.T__.Aggregate("a")).OutE().Has("weight", 
gremlingo.P.Lt(1.0)).InV().Local(gremlingo.T__.Aggregate("a")).OutE().InV().Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
+    
"g_V_hasXname_joshX_aggregateXlocal_aX_outE_hasXweight_ltX1_0XX_inV_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.V().Has("name", 
"josh").Aggregate(gremlingo.Scope.Local, "a").OutE().Has("weight", 
gremlingo.P.Lt(1.0)).InV().Aggregate(gremlingo.Scope.Local, 
"a").OutE().InV().Aggregate(gremlingo.Scope.Local, "a").Cap("a")}}, 
+    
"g_V_hasLabelXpersonX_localXaggregateXaXX_outE_order_byXweightX_limitX1X_inV_localXaggregateXaXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Local(gremlingo.T__.Aggregate("a")).OutE().Order().By("weight").Limit(1).InV().Local(gremlingo.T__.Aggregate("a")).Cap("a")}},
 
+    
"g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_order_byXweightX_limitX1X_inV_aggregateXlocal_aX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Aggregate(gremlingo.Scope.Local, 
"a").OutE().Order().By("weight").Limit(1).InV().Aggregate(gremlingo.Scope.Local,
 "a").Cap("a")}}, 
     "g_V_fail": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fail()}}, 
     "g_V_failXmsgX": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fail("msg")}}, 
     "g_V_unionXout_failX": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.V().Union(gremlingo.T__.Out(), gremlingo.T__.Fail())}}, 
@@ -1527,9 +1567,12 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     "g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Group("m").By("name").By(gremlingo.T__.In("knows").Values("name")).Cap("m")}},
 
     "g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Group("m").By(gremlingo.T__.Label()).By(gremlingo.T__.Label().Count()).Cap("m")}},
 
     "g_V_storeXa_nameX_out_capXaX": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.V().Store("a").By("name").Out().Cap("a")}}, 
+    "g_V_localXaggregateXa_nameXX_out_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a").By("name")).Out().Cap("a")}}, 
     "g_VX1X_storeXaX_byXnameX_out_storeXaX_byXnameX_name_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V(p["vid1"]).Store("a").By("name").Out().Store("a").By("name").Values("name").Cap("a")}},
 
+    "g_VX1X_storeXaX_byXnameX_out_localXaggregateXaX_byXnameXX_name_capXaX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V(p["vid1"]).Store("a").By("name").Out().Local(gremlingo.T__.Aggregate("a").By("name")).Values("name").Cap("a")}},
 
     "g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithSideEffect("a", 
p["xx1"]).V().Both().Values("name").Store("a").Cap("a")}}, 
     
"g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Store("a").By(gremlingo.T__.OutE("created").Count()).Out().Out().Store("a").By(gremlingo.T__.InE("created").Values("weight").Sum()).Cap("a")}},
 
+    
"g_V_localXaggregateXaX_byXoutEXcreatedX_countX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().Local(gremlingo.T__.Aggregate("a").By(gremlingo.T__.OutE("created").Count())).Out().Out().Local(gremlingo.T__.Aggregate("a").By(gremlingo.T__.InE("created").Values("weight").Sum())).Cap("a")}},
 
 }
 
    func GetTraversal(scenarioName string, g *gremlingo.GraphTraversalSource, 
parameters map[string]interface{}) (*gremlingo.GraphTraversal, error) {
diff --git 
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
 
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
index 3e6ed1e525..934239323e 100644
--- 
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
+++ 
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
@@ -80,6 +80,7 @@ const ignoredScenarios = {
   // An associative array containing the scenario name as key, for example:
   'g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX': new 
IgnoreError(ignoreReason.setNotSupported),
   'g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX': new 
IgnoreError(ignoreReason.setNotSupported),
+  'g_withSideEffectXa_setX_V_both_name_localXaggregateX_aXX_capXaX': new 
IgnoreError(ignoreReason.setNotSupported),
   'g_V_out_in_valuesXnameX_fold_dedupXlocalX': new 
IgnoreError(ignoreReason.setNotSupported),
   'g_V_valuesXnonexistantX_fold_differenceXV_valuesXnameX_foldX': new 
IgnoreError(ignoreReason.setNotSupported),
   'g_V_valuesXnameX_fold_differenceXV_valuesXnonexistantX_foldX': new 
IgnoreError(ignoreReason.setNotSupported),
diff --git 
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
 
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
index a15710cfb1..b880409ca0 100644
--- 
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
+++ 
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
@@ -1439,11 +1439,17 @@ const gremlins = {
     g_V_hasLabelXpersonX_aggregateXxX_byXageX_capXxX_asXyX_selectXyX: 
[function({g}) { return 
g.V().hasLabel("person").aggregate("x").by("age").cap("x").as("y").select("y") 
}], 
     g_V_aggregateXxX_byXageX_capXxX: [function({g}) { return 
g.V().aggregate("x").by("age").cap("x") }], 
     g_V_aggregateXlocal_xX_byXageX_capXxX: [function({g}) { return 
g.V().aggregate(Scope.local,"x").by("age").cap("x") }], 
+    g_V_localXaggregateXxX_byXageXX_capXxX: [function({g}) { return 
g.V().local(__.aggregate("x").by("age")).cap("x") }], 
     
g_withStrategiesXProductiveByStrategyX_V_aggregateXlocal_xX_byXageX_capXxX: 
[function({g}) { return g.withStrategies(new 
ProductiveByStrategy({productiveKeys:[]})).V().aggregate(Scope.local,"x").by("age").cap("x")
 }], 
+    
g_withStrategiesXProductiveByStrategyX_V_localXaggregateXxX_byXageXX_capXxX: 
[function({g}) { return g.withStrategies(new 
ProductiveByStrategy({productiveKeys:[]})).V().local(__.aggregate("x").by("age")).cap("x")
 }], 
     g_V_aggregateXlocal_a_nameX_out_capXaX: [function({g}) { return 
g.V().aggregate(Scope.local,"a").by("name").out().cap("a") }], 
+    g_V_localX_aggregateXa_byXnameXX_out_capXaX: [function({g}) { return 
g.V().local(__.aggregate("a").by("name")).out().cap("a") }], 
     
g_VX1X_aggregateXlocal_aX_byXnameX_out_aggregateXlocal_aX_byXnameX_name_capXaX: 
[function({g, vid1}) { return 
g.V(vid1).aggregate(Scope.local,"a").by("name").out().aggregate(Scope.local,"a").by("name").values("name").cap("a")
 }], 
+    
g_VX1X_localXaggregateXaX_byXnameXX_out_localXaggregateXaX_byXnameXX_name_capXaX:
 [function({g, vid1}) { return 
g.V(vid1).local(__.aggregate("a").by("name")).out().local(__.aggregate("a").by("name")).values("name").cap("a")
 }], 
     g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX: 
[function({g, xx1}) { return 
g.withSideEffect("a",xx1).V().both().values("name").aggregate(Scope.local,"a").cap("a")
 }], 
+    g_withSideEffectXa_setX_V_both_name_localXaggregateX_aXX_capXaX: 
[function({g, xx1}) { return 
g.withSideEffect("a",xx1).V().both().values("name").local(__.aggregate("a")).cap("a")
 }], 
     
g_V_aggregateXlocal_aX_byXoutEXcreatedX_countX_out_out_aggregateXlocal_aX_byXinEXcreatedX_weight_sumX:
 [function({g}) { return 
g.V().aggregate(Scope.local,"a").by(__.outE("created").count()).out().out().aggregate(Scope.local,"a").by(__.inE("created").values("weight").sum()).cap("a")
 }], 
+    
g_V_localXaggregateXaX_byXoutEXcreatedX_countXX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX:
 [function({g}) { return 
g.V().local(__.aggregate("a").by(__.outE("created").count())).out().out().local(__.aggregate("a").by(__.inE("created").values("weight").sum())).cap("a")
 }], 
     g_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX: [function({g}) { 
return g.V().aggregate("x").by(__.values("age").is(P.gt(29))).cap("x") }], 
     
g_withStrategiesXProductiveByStrategyX_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX:
 [function({g}) { return g.withStrategies(new 
ProductiveByStrategy({productiveKeys:[]})).V().aggregate("x").by(__.values("age").is(P.gt(29))).cap("x")
 }], 
     g_V_aggregateXxX_byXout_order_byXnameXX_capXxX: [function({g}) { return 
g.V().aggregate("x").by(__.out().order().by("name")).cap("x") }], 
@@ -1451,28 +1457,62 @@ const gremlins = {
     g_V_aggregateXaX_hasXperson_age_gteX30XXX_capXaX_unfold_valuesXnameX: 
[function({g}) { return 
g.V().aggregate("a").has("person","age",P.gte(30)).cap("a").unfold().values("name")
 }], 
     g_withSideEffectXa_1_sumX_V_aggregateXaX_byXageX_capXaX: [function({g}) { 
return 
g.withSideEffect("a",1,Operator.sum).V().aggregate("a").by("age").cap("a") }], 
     g_withSideEffectXa_1_sumX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",1,Operator.sum).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_1_sumX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",1,Operator.sum).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_123_minusX_V_aggregateXaX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",123,Operator.minus).V().aggregate("a").by("age").cap("a") 
}], 
     g_withSideEffectXa_123_minusX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",123,Operator.minus).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_123_minusX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",123,Operator.minus).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_2_multX_V_aggregateXaX_byXageX_capXaX: [function({g}) { 
return 
g.withSideEffect("a",2,Operator.mult).V().aggregate("a").by("age").cap("a") }], 
     g_withSideEffectXa_2_multX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",2,Operator.mult).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_2_multX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",2,Operator.mult).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_876960_divX_V_aggregateXaX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",876960,Operator.div).V().aggregate("a").by("age").cap("a") 
}], 
     g_withSideEffectXa_876960_divX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",876960,Operator.div).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_876960_divX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",876960,Operator.div).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_1_minX_V_aggregateXaX_byXageX_capXaX: [function({g}) { 
return 
g.withSideEffect("a",1,Operator.min).V().aggregate("a").by("age").cap("a") }], 
     g_withSideEffectXa_1_minX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",1,Operator.min).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_1_minX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",1,Operator.min).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_100_minX_V_aggregateXaX_byXageX_capXaX: [function({g}) 
{ return 
g.withSideEffect("a",100,Operator.min).V().aggregate("a").by("age").cap("a") 
}], 
     g_withSideEffectXa_100_minX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",100,Operator.min).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_100_minX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",100,Operator.min).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_1_maxX_V_aggregateXaX_byXageX_capXaX: [function({g}) { 
return 
g.withSideEffect("a",1,Operator.max).V().aggregate("a").by("age").cap("a") }], 
     g_withSideEffectXa_1_maxX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",1,Operator.max).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_1_maxX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",1,Operator.max).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_100_maxX_V_aggregateXaX_byXageX_capXaX: [function({g}) 
{ return 
g.withSideEffect("a",100,Operator.max).V().aggregate("a").by("age").cap("a") 
}], 
     g_withSideEffectXa_100_maxX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",100,Operator.max).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_100_maxX_V_localXaggregateX_aX_byXageX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",100,Operator.max).V().local(__.aggregate("a").by("age")).cap("a")
 }], 
     g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXaX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",true,Operator.and).V().constant(false).aggregate("a").cap("a")
 }], 
     g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXlocal_aX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",true,Operator.and).V().constant(false).aggregate(Scope.local,"a").cap("a")
 }], 
+    
g_withSideEffectXa_true_andX_V_constantXfalseX_localXaggregateX_aXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",true,Operator.and).V().constant(false).local(__.aggregate("a")).cap("a")
 }], 
     g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXaX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",true,Operator.or).V().constant(false).aggregate("a").cap("a")
 }], 
     g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXlocal_aX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",true,Operator.or).V().constant(false).aggregate(Scope.local,"a").cap("a")
 }], 
+    g_withSideEffectXa_true_orX_V_constantXfalseX_localXaggregateX_aXX_capXaX: 
[function({g}) { return 
g.withSideEffect("a",true,Operator.or).V().constant(false).local(__.aggregate("a")).cap("a")
 }], 
     g_withSideEffectXa_xx1_addAllX_V_aggregateXaX_byXageX_capXaX: 
[function({g, xx1}) { return 
g.withSideEffect("a",xx1,Operator.addAll).V().aggregate("a").by("age").cap("a") 
}], 
     g_withSideEffectXa_xx1_addAllX_V_aggregateXlocal_aX_byXageX_capXaX: 
[function({g, xx1}) { return 
g.withSideEffect("a",xx1,Operator.addAll).V().aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    g_withSideEffectXa_1_2_3_addAllX_V_localXaggregateX_aX_byXageXX_capXaX: 
[function({g}) { return g.withSideEffect("a",[1, 2, 
3],Operator.addAll).V().local(__.aggregate("a").by("age")).cap("a") }], 
     g_withSideEffectXa_xx1_assignX_V_aggregateXaX_byXageX_capXaX: 
[function({g, xx1}) { return 
g.withSideEffect("a",xx1,Operator.assign).V().aggregate("a").by("age").cap("a") 
}], 
     
g_withSideEffectXa_xx1_assignX_V_order_byXageX_aggregateXlocal_aX_byXageX_capXaX:
 [function({g, xx1}) { return 
g.withSideEffect("a",xx1,Operator.assign).V().order().by("age").aggregate(Scope.local,"a").by("age").cap("a")
 }], 
+    
g_withSideEffectXa_1_2_3_assignX_V_order_byXageX_localXaggregateX_aX_byXageXX_capXaX:
 [function({g}) { return g.withSideEffect("a",[1, 2, 
3],Operator.assign).V().order().by("age").local(__.aggregate("a").by("age")).cap("a")
 }], 
+    g_V_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX_unfold_dedup: 
[function({g}) { return 
g.V().local(__.aggregate("a")).outE().inV().local(__.aggregate("a")).cap("a").unfold().dedup()
 }], 
+    g_V_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX_unfold_dedup: 
[function({g}) { return 
g.V().aggregate(Scope.local,"a").outE().inV().aggregate(Scope.local,"a").cap("a").unfold().dedup()
 }], 
+    
g_V_hasLabelXpersonX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX:
 [function({g}) { return 
g.V().hasLabel("person").local(__.aggregate("a")).out("created").local(__.aggregate("a")).cap("a")
 }], 
+    
g_V_hasLabelXpersonX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX: 
[function({g}) { return 
g.V().hasLabel("person").aggregate(Scope.local,"a").out("created").aggregate(Scope.local,"a").cap("a")
 }], 
+    
g_V_localXaggregateXaXX_repeatXout_localXaggregateXaXXX_timesX2X_capXaX_unfold_groupCount:
 [function({g}) { return 
g.V().local(__.aggregate("a")).repeat(__.out().local(__.aggregate("a"))).times(2).cap("a").unfold().values("name").groupCount()
 }], 
+    
g_V_aggregateXlocal_aX_repeatXout_aggregateXlocal_aXX_timesX2X_capXaX_unfold_groupCount:
 [function({g}) { return 
g.V().aggregate(Scope.local,"a").repeat(__.out().aggregate(Scope.local,"a")).times(2).cap("a").unfold().values("name").groupCount()
 }], 
+    
g_V_hasXname_markoX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX:
 [function({g}) { return 
g.V().has("name","marko").local(__.aggregate("a")).out("knows").local(__.aggregate("a")).out("created").local(__.aggregate("a")).cap("a")
 }], 
+    
g_V_hasXname_markoX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX:
 [function({g}) { return 
g.V().has("name","marko").aggregate(Scope.local,"a").out("knows").aggregate(Scope.local,"a").out("created").aggregate(Scope.local,"a").cap("a")
 }], 
+    
g_V_hasLabelXsoftwareX_localXaggregateXaXX_inXcreatedX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_capXaX:
 [function({g}) { return 
g.V().hasLabel("software").local(__.aggregate("a")).in_("created").local(__.aggregate("a")).out("knows").local(__.aggregate("a")).cap("a")
 }], 
+    
g_V_hasLabelXsoftwareX_aggregateXlocal_aX_inXcreatedX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_capXaX:
 [function({g}) { return 
g.V().hasLabel("software").aggregate(Scope.local,"a").in_("created").aggregate(Scope.local,"a").out("knows").aggregate(Scope.local,"a").cap("a")
 }], 
+    
g_V_localXaggregateXaXX_outE_hasXweight_lgtX0_5XX_inV_localXaggregateXaXX_capXaX_unfold_path:
 [function({g}) { return 
g.V().local(__.aggregate("a")).outE().has("weight",P.gt(0.5)).inV().local(__.aggregate("a")).cap("a").unfold().path()
 }], 
+    
g_V_aggregateXlocal_aX_outE_hasXweight_lgtX0_5XX_inV_aggregateXlocal_aX_capXaX_unfold_path:
 [function({g}) { return 
g.V().aggregate(Scope.local,"a").outE().has("weight",P.gt(0.5)).inV().aggregate(Scope.local,"a").cap("a").unfold().path()
 }], 
+    
g_V_localXaggregateXaXX_bothE_sampleX1X_otherV_localXaggregateXaXX_capXaX_unfold_groupCount_byXlabelX:
 [function({g}) { return 
g.V().local(__.aggregate("a")).bothE().sample(1).otherV().local(__.aggregate("a")).cap("a").unfold().groupCount().by(T.label)
 }], 
+    
g_V_aggregateXlocal_aX_bothE_sampleX1X_otherV_aggregateXlocal_aX_capXaX_unfold_groupCount_byXlabelX:
 [function({g}) { return 
g.V().aggregate(Scope.local,"a").bothE().sample(1).otherV().aggregate(Scope.local,"a").cap("a").unfold().groupCount().by(T.label)
 }], 
+    
g_V_hasLabelXpersonX_localXaggregateXaXX_outE_inV_simplePath_localXaggregateXaXX_capXaX_unfold_hasLabelXsoftwareX_count:
 [function({g}) { return 
g.V().hasLabel("person").local(__.aggregate("a")).outE().inV().simplePath().local(__.aggregate("a")).cap("a").unfold().hasLabel("software").count()
 }], 
+    
g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_inV_simplePath_aggregateXlocal_aX_capXaX_unfold_hasLabelXsoftwareX_count:
 [function({g}) { return 
g.V().hasLabel("person").aggregate(Scope.local,"a").outE().inV().simplePath().aggregate(Scope.local,"a").cap("a").unfold().hasLabel("software").count()
 }], 
+    
g_V_localXaggregateXaXX_unionXout_inX_localXaggregateXaXX_capXaX_unfold_dedup_valuesXnameX:
 [function({g}) { return 
g.V().local(__.aggregate("a")).union(__.out(),__.in_()).local(__.aggregate("a")).cap("a").unfold().dedup().values("name")
 }], 
+    
g_V_aggregateXlocal_aX_unionXout_inX_aggregateXlocal_aX_capXaX_unfold_dedup_valuesXnameX:
 [function({g}) { return 
g.V().aggregate(Scope.local,"a").union(__.out(),__.in_()).aggregate(Scope.local,"a").cap("a").unfold().dedup().values("name")
 }], 
+    
g_V_hasXname_joshX_localXaggregateXaXX_outE_hasXweight_ltX1_0XX_inV_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX:
 [function({g}) { return 
g.V().has("name","josh").local(__.aggregate("a")).outE().has("weight",P.lt(1.0)).inV().local(__.aggregate("a")).outE().inV().local(__.aggregate("a")).cap("a")
 }], 
+    
g_V_hasXname_joshX_aggregateXlocal_aX_outE_hasXweight_ltX1_0XX_inV_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX:
 [function({g}) { return 
g.V().has("name","josh").aggregate(Scope.local,"a").outE().has("weight",P.lt(1.0)).inV().aggregate(Scope.local,"a").outE().inV().aggregate(Scope.local,"a").cap("a")
 }], 
+    
g_V_hasLabelXpersonX_localXaggregateXaXX_outE_order_byXweightX_limitX1X_inV_localXaggregateXaXX_capXaX:
 [function({g}) { return 
g.V().hasLabel("person").local(__.aggregate("a")).outE().order().by("weight").limit(1).inV().local(__.aggregate("a")).cap("a")
 }], 
+    
g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_order_byXweightX_limitX1X_inV_aggregateXlocal_aX_capXaX:
 [function({g}) { return 
g.V().hasLabel("person").aggregate(Scope.local,"a").outE().order().by("weight").limit(1).inV().aggregate(Scope.local,"a").cap("a")
 }], 
     g_V_fail: [function({g}) { return g.V().fail() }], 
     g_V_failXmsgX: [function({g}) { return g.V().fail("msg") }], 
     g_V_unionXout_failX: [function({g}) { return 
g.V().union(__.out(),__.fail()) }], 
@@ -1547,9 +1587,12 @@ const gremlins = {
     g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX: [function({g}) { return 
g.V().group("m").by("name").by(__.in_("knows").values("name")).cap("m") }], 
     g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX: [function({g}) { return 
g.V().group("m").by(__.label()).by(__.label().count()).cap("m") }], 
     g_V_storeXa_nameX_out_capXaX: [function({g}) { return 
g.V().store("a").by("name").out().cap("a") }], 
+    g_V_localXaggregateXa_nameXX_out_capXaX: [function({g}) { return 
g.V().local(__.aggregate("a").by("name")).out().cap("a") }], 
     g_VX1X_storeXaX_byXnameX_out_storeXaX_byXnameX_name_capXaX: [function({g, 
vid1}) { return 
g.V(vid1).store("a").by("name").out().store("a").by("name").values("name").cap("a")
 }], 
+    g_VX1X_storeXaX_byXnameX_out_localXaggregateXaX_byXnameXX_name_capXaX: 
[function({g, vid1}) { return 
g.V(vid1).store("a").by("name").out().local(__.aggregate("a").by("name")).values("name").cap("a")
 }], 
     g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX: [function({g, xx1}) { 
return g.withSideEffect("a",xx1).V().both().values("name").store("a").cap("a") 
}], 
     
g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX:
 [function({g}) { return 
g.V().store("a").by(__.outE("created").count()).out().out().store("a").by(__.inE("created").values("weight").sum()).cap("a")
 }], 
+    
g_V_localXaggregateXaX_byXoutEXcreatedX_countX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX:
 [function({g}) { return 
g.V().local(__.aggregate("a").by(__.outE("created").count())).out().out().local(__.aggregate("a").by(__.inE("created").values("weight").sum())).cap("a")
 }], 
 }
 
 exports.gremlin = gremlins
diff --git a/gremlin-python/src/main/python/radish/gremlin.py 
b/gremlin-python/src/main/python/radish/gremlin.py
index 9601ce5ee6..5060c46453 100644
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@ -1421,11 +1421,17 @@ world.gremlins = {
     'g_V_hasLabelXpersonX_aggregateXxX_byXageX_capXxX_asXyX_selectXyX': 
[(lambda 
g:g.V().has_label('person').aggregate('x').by('age').cap('x').as_('y').select('y'))],
 
     'g_V_aggregateXxX_byXageX_capXxX': [(lambda 
g:g.V().aggregate('x').by('age').cap('x'))], 
     'g_V_aggregateXlocal_xX_byXageX_capXxX': [(lambda 
g:g.V().aggregate(Scope.local,'x').by('age').cap('x'))], 
+    'g_V_localXaggregateXxX_byXageXX_capXxX': [(lambda 
g:g.V().local(__.aggregate('x').by('age')).cap('x'))], 
     
'g_withStrategiesXProductiveByStrategyX_V_aggregateXlocal_xX_byXageX_capXxX': 
[(lambda 
g:g.with_strategies(*[TraversalStrategy('ProductiveByStrategy',{'productiveKeys':[],'strategy':'org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy'},
 
'org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy')]).V().aggregate(Scope.local,'x').by('age').cap('x'))],
 
+    
'g_withStrategiesXProductiveByStrategyX_V_localXaggregateXxX_byXageXX_capXxX': 
[(lambda 
g:g.with_strategies(*[TraversalStrategy('ProductiveByStrategy',{'productiveKeys':[],'strategy':'org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy'},
 
'org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy')]).V().local(__.aggregate('x').by('age')).cap('x'))],
 
     'g_V_aggregateXlocal_a_nameX_out_capXaX': [(lambda 
g:g.V().aggregate(Scope.local,'a').by('name').out().cap('a'))], 
+    'g_V_localX_aggregateXa_byXnameXX_out_capXaX': [(lambda 
g:g.V().local(__.aggregate('a').by('name')).out().cap('a'))], 
     
'g_VX1X_aggregateXlocal_aX_byXnameX_out_aggregateXlocal_aX_byXnameX_name_capXaX':
 [(lambda g, 
vid1=None:g.V(vid1).aggregate(Scope.local,'a').by('name').out().aggregate(Scope.local,'a').by('name').name.cap('a'))],
 
+    
'g_VX1X_localXaggregateXaX_byXnameXX_out_localXaggregateXaX_byXnameXX_name_capXaX':
 [(lambda g, 
vid1=None:g.V(vid1).local(__.aggregate('a').by('name')).out().local(__.aggregate('a').by('name')).name.cap('a'))],
 
     'g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX': [(lambda 
g, 
xx1=None:g.with_side_effect('a',xx1).V().both().name.aggregate(Scope.local,'a').cap('a'))],
 
+    'g_withSideEffectXa_setX_V_both_name_localXaggregateX_aXX_capXaX': 
[(lambda g, 
xx1=None:g.with_side_effect('a',xx1).V().both().name.local(__.aggregate('a')).cap('a'))],
 
     
'g_V_aggregateXlocal_aX_byXoutEXcreatedX_countX_out_out_aggregateXlocal_aX_byXinEXcreatedX_weight_sumX':
 [(lambda 
g:g.V().aggregate(Scope.local,'a').by(__.out_e('created').count()).out().out().aggregate(Scope.local,'a').by(__.in_e('created').weight.sum_()).cap('a'))],
 
+    
'g_V_localXaggregateXaX_byXoutEXcreatedX_countXX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX':
 [(lambda 
g:g.V().local(__.aggregate('a').by(__.out_e('created').count())).out().out().local(__.aggregate('a').by(__.in_e('created').weight.sum_())).cap('a'))],
 
     'g_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX': [(lambda 
g:g.V().aggregate('x').by(__.age.is_(P.gt(29))).cap('x'))], 
     
'g_withStrategiesXProductiveByStrategyX_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX':
 [(lambda 
g:g.with_strategies(*[TraversalStrategy('ProductiveByStrategy',{'productiveKeys':[],'strategy':'org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy'},
 
'org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy')]).V().aggregate('x').by(__.age.is_(P.gt(29))).cap('x'))],
 
     'g_V_aggregateXxX_byXout_order_byXnameXX_capXxX': [(lambda 
g:g.V().aggregate('x').by(__.out().order().by('name')).cap('x'))], 
@@ -1433,28 +1439,62 @@ world.gremlins = {
     'g_V_aggregateXaX_hasXperson_age_gteX30XXX_capXaX_unfold_valuesXnameX': 
[(lambda 
g:g.V().aggregate('a').has('person','age',P.gte(30)).cap('a').unfold().name)], 
     'g_withSideEffectXa_1_sumX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',1,Operator.sum_).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_1_sumX_V_aggregateXlocal_aX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',1,Operator.sum_).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_1_sumX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',1,Operator.sum_).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_123_minusX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',123,Operator.minus).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_123_minusX_V_aggregateXlocal_aX_byXageX_capXaX': 
[(lambda 
g:g.with_side_effect('a',123,Operator.minus).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_123_minusX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',123,Operator.minus).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_2_multX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',2,Operator.mult).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_2_multX_V_aggregateXlocal_aX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',2,Operator.mult).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_2_multX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',2,Operator.mult).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_876960_divX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',876960,Operator.div).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_876960_divX_V_aggregateXlocal_aX_byXageX_capXaX': 
[(lambda 
g:g.with_side_effect('a',876960,Operator.div).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_876960_divX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',876960,Operator.div).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_1_minX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',1,Operator.min_).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_1_minX_V_aggregateXlocal_aX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',1,Operator.min_).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_1_minX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',1,Operator.min_).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_100_minX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',100,Operator.min_).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_100_minX_V_aggregateXlocal_aX_byXageX_capXaX': 
[(lambda 
g:g.with_side_effect('a',100,Operator.min_).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_100_minX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',100,Operator.min_).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_1_maxX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',1,Operator.max_).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_1_maxX_V_aggregateXlocal_aX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',1,Operator.max_).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_1_maxX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',1,Operator.max_).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_100_maxX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g:g.with_side_effect('a',100,Operator.max_).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_100_maxX_V_aggregateXlocal_aX_byXageX_capXaX': 
[(lambda 
g:g.with_side_effect('a',100,Operator.max_).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_100_maxX_V_localXaggregateX_aX_byXageX_capXaX': 
[(lambda 
g:g.with_side_effect('a',100,Operator.max_).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXaX_capXaX': 
[(lambda 
g:g.with_side_effect('a',True,Operator.and_).V().constant(False).aggregate('a').cap('a'))],
 
     
'g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXlocal_aX_capXaX': 
[(lambda 
g:g.with_side_effect('a',True,Operator.and_).V().constant(False).aggregate(Scope.local,'a').cap('a'))],
 
+    
'g_withSideEffectXa_true_andX_V_constantXfalseX_localXaggregateX_aXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',True,Operator.and_).V().constant(False).local(__.aggregate('a')).cap('a'))],
 
     'g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXaX_capXaX': 
[(lambda 
g:g.with_side_effect('a',True,Operator.or_).V().constant(False).aggregate('a').cap('a'))],
 
     'g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXlocal_aX_capXaX': 
[(lambda 
g:g.with_side_effect('a',True,Operator.or_).V().constant(False).aggregate(Scope.local,'a').cap('a'))],
 
+    
'g_withSideEffectXa_true_orX_V_constantXfalseX_localXaggregateX_aXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',True,Operator.or_).V().constant(False).local(__.aggregate('a')).cap('a'))],
 
     'g_withSideEffectXa_xx1_addAllX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g, 
xx1=None:g.with_side_effect('a',xx1,Operator.add_all).V().aggregate('a').by('age').cap('a'))],
 
     'g_withSideEffectXa_xx1_addAllX_V_aggregateXlocal_aX_byXageX_capXaX': 
[(lambda g, 
xx1=None:g.with_side_effect('a',xx1,Operator.add_all).V().aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    'g_withSideEffectXa_1_2_3_addAllX_V_localXaggregateX_aX_byXageXX_capXaX': 
[(lambda 
g:g.with_side_effect('a',[1,2,3],Operator.add_all).V().local(__.aggregate('a').by('age')).cap('a'))],
 
     'g_withSideEffectXa_xx1_assignX_V_aggregateXaX_byXageX_capXaX': [(lambda 
g, 
xx1=None:g.with_side_effect('a',xx1,Operator.assign).V().aggregate('a').by('age').cap('a'))],
 
     
'g_withSideEffectXa_xx1_assignX_V_order_byXageX_aggregateXlocal_aX_byXageX_capXaX':
 [(lambda g, 
xx1=None:g.with_side_effect('a',xx1,Operator.assign).V().order().by('age').aggregate(Scope.local,'a').by('age').cap('a'))],
 
+    
'g_withSideEffectXa_1_2_3_assignX_V_order_byXageX_localXaggregateX_aX_byXageXX_capXaX':
 [(lambda 
g:g.with_side_effect('a',[1,2,3],Operator.assign).V().order().by('age').local(__.aggregate('a').by('age')).cap('a'))],
 
+    
'g_V_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX_unfold_dedup': 
[(lambda 
g:g.V().local(__.aggregate('a')).out_e().in_v().local(__.aggregate('a')).cap('a').unfold().dedup())],
 
+    'g_V_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX_unfold_dedup': 
[(lambda 
g:g.V().aggregate(Scope.local,'a').out_e().in_v().aggregate(Scope.local,'a').cap('a').unfold().dedup())],
 
+    
'g_V_hasLabelXpersonX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX':
 [(lambda 
g:g.V().has_label('person').local(__.aggregate('a')).out('created').local(__.aggregate('a')).cap('a'))],
 
+    
'g_V_hasLabelXpersonX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX':
 [(lambda 
g:g.V().has_label('person').aggregate(Scope.local,'a').out('created').aggregate(Scope.local,'a').cap('a'))],
 
+    
'g_V_localXaggregateXaXX_repeatXout_localXaggregateXaXXX_timesX2X_capXaX_unfold_groupCount':
 [(lambda 
g:g.V().local(__.aggregate('a')).repeat(__.out().local(__.aggregate('a'))).times(2).cap('a').unfold().name.group_count())],
 
+    
'g_V_aggregateXlocal_aX_repeatXout_aggregateXlocal_aXX_timesX2X_capXaX_unfold_groupCount':
 [(lambda 
g:g.V().aggregate(Scope.local,'a').repeat(__.out().aggregate(Scope.local,'a')).times(2).cap('a').unfold().name.group_count())],
 
+    
'g_V_hasXname_markoX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX':
 [(lambda 
g:g.V().has('name','marko').local(__.aggregate('a')).out('knows').local(__.aggregate('a')).out('created').local(__.aggregate('a')).cap('a'))],
 
+    
'g_V_hasXname_markoX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX':
 [(lambda 
g:g.V().has('name','marko').aggregate(Scope.local,'a').out('knows').aggregate(Scope.local,'a').out('created').aggregate(Scope.local,'a').cap('a'))],
 
+    
'g_V_hasLabelXsoftwareX_localXaggregateXaXX_inXcreatedX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_capXaX':
 [(lambda 
g:g.V().has_label('software').local(__.aggregate('a')).in_('created').local(__.aggregate('a')).out('knows').local(__.aggregate('a')).cap('a'))],
 
+    
'g_V_hasLabelXsoftwareX_aggregateXlocal_aX_inXcreatedX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_capXaX':
 [(lambda 
g:g.V().has_label('software').aggregate(Scope.local,'a').in_('created').aggregate(Scope.local,'a').out('knows').aggregate(Scope.local,'a').cap('a'))],
 
+    
'g_V_localXaggregateXaXX_outE_hasXweight_lgtX0_5XX_inV_localXaggregateXaXX_capXaX_unfold_path':
 [(lambda 
g:g.V().local(__.aggregate('a')).out_e().has('weight',P.gt(float(0.5))).in_v().local(__.aggregate('a')).cap('a').unfold().path())],
 
+    
'g_V_aggregateXlocal_aX_outE_hasXweight_lgtX0_5XX_inV_aggregateXlocal_aX_capXaX_unfold_path':
 [(lambda 
g:g.V().aggregate(Scope.local,'a').out_e().has('weight',P.gt(float(0.5))).in_v().aggregate(Scope.local,'a').cap('a').unfold().path())],
 
+    
'g_V_localXaggregateXaXX_bothE_sampleX1X_otherV_localXaggregateXaXX_capXaX_unfold_groupCount_byXlabelX':
 [(lambda 
g:g.V().local(__.aggregate('a')).both_e().sample(1).other_v().local(__.aggregate('a')).cap('a').unfold().group_count().by(T.label))],
 
+    
'g_V_aggregateXlocal_aX_bothE_sampleX1X_otherV_aggregateXlocal_aX_capXaX_unfold_groupCount_byXlabelX':
 [(lambda 
g:g.V().aggregate(Scope.local,'a').both_e().sample(1).other_v().aggregate(Scope.local,'a').cap('a').unfold().group_count().by(T.label))],
 
+    
'g_V_hasLabelXpersonX_localXaggregateXaXX_outE_inV_simplePath_localXaggregateXaXX_capXaX_unfold_hasLabelXsoftwareX_count':
 [(lambda 
g:g.V().has_label('person').local(__.aggregate('a')).out_e().in_v().simple_path().local(__.aggregate('a')).cap('a').unfold().has_label('software').count())],
 
+    
'g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_inV_simplePath_aggregateXlocal_aX_capXaX_unfold_hasLabelXsoftwareX_count':
 [(lambda 
g:g.V().has_label('person').aggregate(Scope.local,'a').out_e().in_v().simple_path().aggregate(Scope.local,'a').cap('a').unfold().has_label('software').count())],
 
+    
'g_V_localXaggregateXaXX_unionXout_inX_localXaggregateXaXX_capXaX_unfold_dedup_valuesXnameX':
 [(lambda 
g:g.V().local(__.aggregate('a')).union(__.out(),__.in_()).local(__.aggregate('a')).cap('a').unfold().dedup().name)],
 
+    
'g_V_aggregateXlocal_aX_unionXout_inX_aggregateXlocal_aX_capXaX_unfold_dedup_valuesXnameX':
 [(lambda 
g:g.V().aggregate(Scope.local,'a').union(__.out(),__.in_()).aggregate(Scope.local,'a').cap('a').unfold().dedup().name)],
 
+    
'g_V_hasXname_joshX_localXaggregateXaXX_outE_hasXweight_ltX1_0XX_inV_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX':
 [(lambda 
g:g.V().has('name','josh').local(__.aggregate('a')).out_e().has('weight',P.lt(float(1.0))).in_v().local(__.aggregate('a')).out_e().in_v().local(__.aggregate('a')).cap('a'))],
 
+    
'g_V_hasXname_joshX_aggregateXlocal_aX_outE_hasXweight_ltX1_0XX_inV_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX':
 [(lambda 
g:g.V().has('name','josh').aggregate(Scope.local,'a').out_e().has('weight',P.lt(float(1.0))).in_v().aggregate(Scope.local,'a').out_e().in_v().aggregate(Scope.local,'a').cap('a'))],
 
+    
'g_V_hasLabelXpersonX_localXaggregateXaXX_outE_order_byXweightX_limitX1X_inV_localXaggregateXaXX_capXaX':
 [(lambda 
g:g.V().has_label('person').local(__.aggregate('a')).out_e().order().by('weight')[0:1].in_v().local(__.aggregate('a')).cap('a'))],
 
+    
'g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_order_byXweightX_limitX1X_inV_aggregateXlocal_aX_capXaX':
 [(lambda 
g:g.V().has_label('person').aggregate(Scope.local,'a').out_e().order().by('weight')[0:1].in_v().aggregate(Scope.local,'a').cap('a'))],
 
     'g_V_fail': [(lambda g:g.V().fail())], 
     'g_V_failXmsgX': [(lambda g:g.V().fail('msg'))], 
     'g_V_unionXout_failX': [(lambda g:g.V().union(__.out(),__.fail()))], 
@@ -1529,7 +1569,10 @@ world.gremlins = {
     'g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX': [(lambda 
g:g.V().group('m').by('name').by(__.in_('knows').name).cap('m'))], 
     'g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX': [(lambda 
g:g.V().group('m').by(__.label()).by(__.label().count()).cap('m'))], 
     'g_V_storeXa_nameX_out_capXaX': [(lambda 
g:g.V().store('a').by('name').out().cap('a'))], 
+    'g_V_localXaggregateXa_nameXX_out_capXaX': [(lambda 
g:g.V().local(__.aggregate('a').by('name')).out().cap('a'))], 
     'g_VX1X_storeXaX_byXnameX_out_storeXaX_byXnameX_name_capXaX': [(lambda g, 
vid1=None:g.V(vid1).store('a').by('name').out().store('a').by('name').name.cap('a'))],
 
+    'g_VX1X_storeXaX_byXnameX_out_localXaggregateXaX_byXnameXX_name_capXaX': 
[(lambda g, 
vid1=None:g.V(vid1).store('a').by('name').out().local(__.aggregate('a').by('name')).name.cap('a'))],
 
     'g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX': [(lambda g, 
xx1=None:g.with_side_effect('a',xx1).V().both().name.store('a').cap('a'))], 
     
'g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX':
 [(lambda 
g:g.V().store('a').by(__.out_e('created').count()).out().out().store('a').by(__.in_e('created').weight.sum_()).cap('a'))],
 
+    
'g_V_localXaggregateXaX_byXoutEXcreatedX_countX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX':
 [(lambda 
g:g.V().local(__.aggregate('a').by(__.out_e('created').count())).out().out().local(__.aggregate('a').by(__.in_e('created').weight.sum_())).cap('a'))],
 
 }
diff --git 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Aggregate.feature
 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Aggregate.feature
index f71282e50a..0f0613d722 100644
--- 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Aggregate.feature
+++ 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Aggregate.feature
@@ -124,6 +124,20 @@ Feature: Step - aggregate()
       | d[32].i |
       | d[35].i |
 
+  Scenario: g_V_localXaggregateXxX_byXageXX_capXxX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().local(aggregate("x").by("age")).cap("x")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | d[29].i |
+      | d[27].i |
+      | d[32].i |
+      | d[35].i |
+
   @WithProductiveByStrategy
   Scenario: 
g_withStrategiesXProductiveByStrategyX_V_aggregateXlocal_xX_byXageX_capXxX
     Given the modern graph
@@ -141,6 +155,23 @@ Feature: Step - aggregate()
       | null    |
       | null    |
 
+  @WithProductiveByStrategy
+  Scenario: 
g_withStrategiesXProductiveByStrategyX_V_localXaggregateXxX_byXageXX_capXxX
+    Given the modern graph
+    And the traversal of
+      """
+      
g.withStrategies(ProductiveByStrategy).V().local(aggregate("x").by("age")).cap("x")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | d[29].i |
+      | d[27].i |
+      | d[32].i |
+      | d[35].i |
+      | null    |
+      | null    |
+
   Scenario: g_V_aggregateXlocal_a_nameX_out_capXaX
     Given the modern graph
     And the traversal of
@@ -157,6 +188,22 @@ Feature: Step - aggregate()
     | ripple |
     | peter  |
 
+  Scenario: g_V_localX_aggregateXa_byXnameXX_out_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.V().local(aggregate("a").by("name")).out().cap("a")
+    """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+      | ripple |
+      | peter  |
+
   Scenario: 
g_VX1X_aggregateXlocal_aX_byXnameX_out_aggregateXlocal_aX_byXnameX_name_capXaX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
@@ -166,11 +213,26 @@ Feature: Step - aggregate()
     """
     When iterated next
     Then the result should be unordered
-    | result |
-    | marko |
-    | vadas |
-    | lop |
-    | josh |
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+
+  Scenario: 
g_VX1X_localXaggregateXaX_byXnameXX_out_localXaggregateXaX_byXnameXX_name_capXaX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+    """
+    
g.V(vid1).local(aggregate("a").by("name")).out().local(aggregate("a").by("name")).values("name").cap("a")
+    """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
 
   Scenario: g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX
     Given the modern graph
@@ -181,13 +243,30 @@ Feature: Step - aggregate()
     """
     When iterated next
     Then the result should be unordered
-    | result |
-    | marko |
-    | vadas |
-    | lop |
-    | josh |
-    | ripple |
-    | peter  |
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+      | ripple |
+      | peter  |
+
+  Scenario: g_withSideEffectXa_setX_V_both_name_localXaggregateX_aXX_capXaX
+    Given the modern graph
+    And using the parameter xx1 defined as "s[]"
+    And the traversal of
+    """
+    g.withSideEffect("a", 
xx1).V().both().values("name").local(aggregate("a")).cap("a")
+    """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+      | ripple |
+      | peter  |
 
   Scenario: 
g_V_aggregateXlocal_aX_byXoutEXcreatedX_countX_out_out_aggregateXlocal_aX_byXinEXcreatedX_weight_sumX
     Given the modern graph
@@ -201,15 +280,36 @@ Feature: Step - aggregate()
     """
     When iterated next
     Then the result should be unordered
-    | result |
-    | d[1].l |
-    | d[1].l |
-    | d[0].l |
-    | d[0].l |
-    | d[0].l |
-    | d[2].l |
-    | d[1.0].d |
-    | d[1.0].d |
+      | result |
+      | d[1].l |
+      | d[1].l |
+      | d[0].l |
+      | d[0].l |
+      | d[0].l |
+      | d[2].l |
+      | d[1.0].d |
+      | d[1.0].d |
+
+  Scenario: 
g_V_localXaggregateXaX_byXoutEXcreatedX_countXX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.V().local(aggregate("a").by(__.outE("created").count())).
+    out().out().
+    local(aggregate("a").by(__.inE("created").values("weight").sum())).
+    cap("a")
+    """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | d[1].l |
+      | d[1].l |
+      | d[0].l |
+      | d[0].l |
+      | d[0].l |
+      | d[2].l |
+      | d[1.0].d |
+      | d[1.0].d |
 
   Scenario: g_V_aggregateXxX_byXvaluesXageX_isXgtX29XXX_capXxX
     Given the modern graph
@@ -295,8 +395,8 @@ Feature: Step - aggregate()
     """
     When iterated to list
     Then the result should be unordered
-    | result   |
-    | d[124].i |
+      | result   |
+      | d[124].i |
 
   Scenario: g_withSideEffectXa_1_sumX_V_aggregateXlocal_aX_byXageX_capXaX
     Given the modern graph
@@ -309,6 +409,17 @@ Feature: Step - aggregate()
       | result   |
       | d[124].i |
 
+  Scenario: g_withSideEffectXa_1_sumX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 1, 
Operator.sum).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result   |
+      | d[124].i |
+
   @GraphComputerVerificationStrategyNotSupported
   Scenario: g_withSideEffectXa_123_minusX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
@@ -333,6 +444,18 @@ Feature: Step - aggregate()
       | result |
       | d[0].i |
 
+  @GraphComputerVerificationStrategyNotSupported
+  Scenario: g_withSideEffectXa_123_minusX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 123, 
Operator.minus).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[0].i |
+
   Scenario: g_withSideEffectXa_2_multX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
     And the traversal of
@@ -355,6 +478,17 @@ Feature: Step - aggregate()
       | result |
       | d[1753920].i |
 
+  Scenario: g_withSideEffectXa_2_multX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 2, 
Operator.mult).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[1753920].i |
+
   @GraphComputerVerificationStrategyNotSupported
   Scenario: g_withSideEffectXa_876960_divX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
@@ -379,6 +513,18 @@ Feature: Step - aggregate()
       | result |
       | d[1].i |
 
+  @GraphComputerVerificationStrategyNotSupported
+  Scenario: 
g_withSideEffectXa_876960_divX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 876960, 
Operator.div).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[1].i |
+
   Scenario: g_withSideEffectXa_1_minX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
     And the traversal of
@@ -401,6 +547,17 @@ Feature: Step - aggregate()
       | result |
       | d[1].i |
 
+  Scenario: g_withSideEffectXa_1_minX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 1, 
Operator.min).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[1].i |
+
   Scenario: g_withSideEffectXa_100_minX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
     And the traversal of
@@ -423,6 +580,17 @@ Feature: Step - aggregate()
       | result |
       | d[27].i |
 
+  Scenario: g_withSideEffectXa_100_minX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 100, 
Operator.min).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[27].i |
+
   Scenario: g_withSideEffectXa_1_maxX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
     And the traversal of
@@ -445,6 +613,17 @@ Feature: Step - aggregate()
       | result |
       | d[35].i |
 
+  Scenario: g_withSideEffectXa_1_maxX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 1, 
Operator.max).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[35].i |
+
   Scenario: g_withSideEffectXa_100_maxX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
     And the traversal of
@@ -467,6 +646,17 @@ Feature: Step - aggregate()
       | result |
       | d[100].i |
 
+  Scenario: g_withSideEffectXa_100_maxX_V_localXaggregateX_aX_byXageX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", 100, 
Operator.max).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[100].i |
+
   Scenario: g_withSideEffectXa_true_andX_V_constantXfalseX_aggregateXaX_capXaX
     Given the modern graph
     And the traversal of
@@ -489,6 +679,17 @@ Feature: Step - aggregate()
       | result |
       | false |
 
+  Scenario: 
g_withSideEffectXa_true_andX_V_constantXfalseX_localXaggregateX_aXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", true, 
Operator.and).V().constant(false).local(aggregate("a")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | false |
+
   Scenario: g_withSideEffectXa_true_orX_V_constantXfalseX_aggregateXaX_capXaX
     Given the modern graph
     And the traversal of
@@ -511,6 +712,17 @@ Feature: Step - aggregate()
       | result |
       | true |
 
+  Scenario: 
g_withSideEffectXa_true_orX_V_constantXfalseX_localXaggregateX_aXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", true, 
Operator.or).V().constant(false).local(aggregate("a")).cap("a")
+    """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | true |
+
   Scenario: g_withSideEffectXa_xx1_addAllX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
     And using the parameter xx1 defined as "l[d[1].i,d[2].i,d[3].i]"
@@ -547,6 +759,23 @@ Feature: Step - aggregate()
       | d[32].i |
       | d[35].i |
 
+  Scenario: 
g_withSideEffectXa_1_2_3_addAllX_V_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    """
+    g.withSideEffect("a", [1i,2i,3i], 
Operator.addAll).V().local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | d[1].i |
+      | d[2].i |
+      | d[3].i |
+      | d[29].i |
+      | d[27].i |
+      | d[32].i |
+      | d[35].i |
+
   @GraphComputerVerificationInjectionNotSupported
   Scenario: g_withSideEffectXa_xx1_assignX_V_aggregateXaX_byXageX_capXaX
     Given the modern graph
@@ -576,3 +805,316 @@ Feature: Step - aggregate()
     Then the result should be unordered
       | result |
       | d[35].i |
+
+  @GraphComputerVerificationInjectionNotSupported
+  Scenario: 
g_withSideEffectXa_1_2_3_assignX_V_order_byXageX_localXaggregateX_aX_byXageXX_capXaX
+    Given the modern graph
+    And the traversal of
+    # add order().by("age") to deterministically assign a vertex with the 
largest age value at the end
+    """
+    g.withSideEffect("a", [1i,2i,3i], 
Operator.assign).V().order().by("age").local(aggregate("a").by("age")).cap("a")
+    """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | d[35].i |
+
+  Scenario: 
g_V_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX_unfold_dedup
+    Given the modern graph
+    And the traversal of
+      """
+      
g.V().local(aggregate("a")).outE().inV().local(aggregate("a")).cap("a").unfold().dedup()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[lop] |
+      | v[josh] |
+      | v[ripple] |
+      | v[peter] |
+
+  Scenario: 
g_V_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX_unfold_dedup
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().aggregate(Scope.local, "a").outE().inV().aggregate(Scope.local, 
"a").cap("a").unfold().dedup()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[lop] |
+      | v[josh] |
+      | v[ripple] |
+      | v[peter] |
+
+  Scenario: 
g_V_hasLabelXpersonX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      
g.V().hasLabel("person").local(aggregate("a")).out("created").local(aggregate("a")).cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[lop] |
+      | v[lop] |
+      | v[lop] |
+      | v[vadas] |
+      | v[ripple] |
+      | v[josh]  |
+      | v[peter] |
+
+  Scenario: 
g_V_hasLabelXpersonX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+       g.V().hasLabel("person").aggregate(Scope.local, 
"a").out("created").aggregate(Scope.local, "a").cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[lop] |
+      | v[lop] |
+      | v[lop] |
+      | v[vadas] |
+      | v[ripple] |
+      | v[josh]  |
+      | v[peter] |
+
+  Scenario: 
g_V_localXaggregateXaXX_repeatXout_localXaggregateXaXXX_timesX2X_capXaX_unfold_groupCount
+    Given the modern graph
+    And the traversal of
+      """
+      
g.V().local(aggregate("a")).repeat(__.out().local(aggregate("a"))).times(2).cap("a").unfold().values("name").groupCount()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | 
m[{"marko":"d[1].l","lop":"d[5].l","vadas":"d[2].l","josh":"d[2].l","ripple":"d[3].l","peter":"d[1].l"}]
 |
+
+  Scenario: 
g_V_aggregateXlocal_aX_repeatXout_aggregateXlocal_aXX_timesX2X_capXaX_unfold_groupCount
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().aggregate(Scope.local, "a").repeat(__.out().aggregate(Scope.local, 
"a")).times(2).cap("a").unfold().values("name").groupCount()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | 
m[{"marko":"d[1].l","lop":"d[5].l","vadas":"d[2].l","josh":"d[2].l","ripple":"d[3].l","peter":"d[1].l"}]
 |
+
+  Scenario: 
g_V_hasXname_markoX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_outXcreatedX_localXaggregateXaXX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().has("name", 
"marko").local(aggregate("a")).out("knows").local(aggregate("a")).out("created").local(aggregate("a")).cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[josh] |
+      | v[lop] |
+      | v[ripple] |
+
+  Scenario: 
g_V_hasXname_markoX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_outXcreatedX_aggregateXlocal_aX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().has("name", "marko").aggregate(Scope.local, 
"a").out("knows").aggregate(Scope.local, 
"a").out("created").aggregate(Scope.local, "a").cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[josh] |
+      | v[lop] |
+      | v[ripple] |
+
+  Scenario: 
g_V_hasLabelXsoftwareX_localXaggregateXaXX_inXcreatedX_localXaggregateXaXX_outXknowsX_localXaggregateXaXX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      
g.V().hasLabel("software").local(aggregate("a")).in("created").local(aggregate("a")).out("knows").local(aggregate("a")).cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[lop] |
+      | v[marko] |
+      | v[josh] |
+      | v[josh] |
+      | v[josh] |
+      | v[peter] |
+      | v[vadas] |
+      | v[ripple] |
+
+  Scenario: 
g_V_hasLabelXsoftwareX_aggregateXlocal_aX_inXcreatedX_aggregateXlocal_aX_outXknowsX_aggregateXlocal_aX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().hasLabel("software").aggregate(Scope.local, 
"a").in("created").aggregate(Scope.local, 
"a").out("knows").aggregate(Scope.local, "a").cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[lop] |
+      | v[marko] |
+      | v[josh] |
+      | v[josh] |
+      | v[josh] |
+      | v[peter] |
+      | v[vadas] |
+      | v[ripple] |
+
+  Scenario: 
g_V_localXaggregateXaXX_outE_hasXweight_lgtX0_5XX_inV_localXaggregateXaXX_capXaX_unfold_path
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().local(aggregate("a")).outE().has("weight", 
P.gt(0.5)).inV().local(aggregate("a")).cap("a").unfold().path()
+      """
+    When iterated to list
+    Then the result should have a count of 8
+
+  Scenario: 
g_V_aggregateXlocal_aX_outE_hasXweight_lgtX0_5XX_inV_aggregateXlocal_aX_capXaX_unfold_path
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().aggregate(Scope.local, "a").outE().has("weight", 
P.gt(0.5)).inV().aggregate(Scope.local, "a").cap("a").unfold().path()
+      """
+    When iterated to list
+    Then the result should have a count of 8
+
+  Scenario: 
g_V_localXaggregateXaXX_bothE_sampleX1X_otherV_localXaggregateXaXX_capXaX_unfold_groupCount_byXlabelX
+    Given the modern graph
+    And the traversal of
+      """
+      
g.V().local(aggregate("a")).bothE().sample(1).otherV().local(aggregate("a")).cap("a").unfold().groupCount().by(T.label)
+      """
+    When iterated to list
+    Then the result should have a count of 1
+
+  Scenario: 
g_V_aggregateXlocal_aX_bothE_sampleX1X_otherV_aggregateXlocal_aX_capXaX_unfold_groupCount_byXlabelX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().aggregate(Scope.local, 
"a").bothE().sample(1).otherV().aggregate(Scope.local, 
"a").cap("a").unfold().groupCount().by(T.label)
+      """
+    When iterated to list
+    Then the result should have a count of 1
+
+  Scenario: 
g_V_hasLabelXpersonX_localXaggregateXaXX_outE_inV_simplePath_localXaggregateXaXX_capXaX_unfold_hasLabelXsoftwareX_count
+    Given the modern graph
+    And the traversal of
+      """
+      
g.V().hasLabel("person").local(aggregate("a")).outE().inV().simplePath().local(aggregate("a")).cap("a").unfold().hasLabel("software").count()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[4].l |
+
+  Scenario: 
g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_inV_simplePath_aggregateXlocal_aX_capXaX_unfold_hasLabelXsoftwareX_count
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().hasLabel("person").aggregate(Scope.local, 
"a").outE().inV().simplePath().aggregate(Scope.local, 
"a").cap("a").unfold().hasLabel("software").count()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[4].l |
+
+  Scenario: 
g_V_localXaggregateXaXX_unionXout_inX_localXaggregateXaXX_capXaX_unfold_dedup_valuesXnameX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().local(aggregate("a")).union(__.out(), 
__.in()).local(aggregate("a")).cap("a").unfold().dedup().values("name")
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+      | ripple |
+      | peter |
+
+  Scenario: 
g_V_aggregateXlocal_aX_unionXout_inX_aggregateXlocal_aX_capXaX_unfold_dedup_valuesXnameX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().aggregate(Scope.local, "a").union(__.out(), 
__.in()).aggregate(Scope.local, "a").cap("a").unfold().dedup().values("name")
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+      | ripple |
+      | peter |
+
+  Scenario: 
g_V_hasXname_joshX_localXaggregateXaXX_outE_hasXweight_ltX1_0XX_inV_localXaggregateXaXX_outE_inV_localXaggregateXaXX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().has("name", "josh").local(aggregate("a")).outE().has("weight", 
P.lt(1.0)).inV().local(aggregate("a")).outE().inV().local(aggregate("a")).cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[josh] |
+      | v[lop] |
+
+  Scenario: 
g_V_hasXname_joshX_aggregateXlocal_aX_outE_hasXweight_ltX1_0XX_inV_aggregateXlocal_aX_outE_inV_aggregateXlocal_aX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().has("name", "josh").aggregate(Scope.local, 
"a").outE().has("weight", P.lt(1.0)).inV().aggregate(Scope.local, 
"a").outE().inV().aggregate(Scope.local, "a").cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[josh] |
+      | v[lop] |
+
+  Scenario: 
g_V_hasLabelXpersonX_localXaggregateXaXX_outE_order_byXweightX_limitX1X_inV_localXaggregateXaXX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      
g.V().hasLabel("person").local(aggregate("a")).outE().order().by("weight").limit(1).inV().local(aggregate("a")).cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[josh] |
+      | v[lop] |
+      | v[peter] |
+
+  Scenario: 
g_V_hasLabelXpersonX_aggregateXlocal_aX_outE_order_byXweightX_limitX1X_inV_aggregateXlocal_aX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().hasLabel("person").aggregate(Scope.local, 
"a").outE().order().by("weight").limit(1).inV().aggregate(Scope.local, 
"a").cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[josh] |
+      | v[lop] |
+      | v[peter] |
\ No newline at end of file
diff --git 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Store.feature
 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Store.feature
index bf20cea1c3..11bc6596da 100644
--- 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Store.feature
+++ 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Store.feature
@@ -34,6 +34,22 @@ Feature: Step - store()
       | ripple |
       | peter  |
 
+  Scenario: g_V_localXaggregateXa_nameXX_out_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().local(aggregate("a").by("name")).out().cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+      | ripple |
+      | peter  |
+
   Scenario: g_VX1X_storeXaX_byXnameX_out_storeXaX_byXnameX_name_capXaX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
@@ -49,6 +65,21 @@ Feature: Step - store()
       | lop |
       | josh |
 
+  Scenario: 
g_VX1X_storeXaX_byXnameX_out_localXaggregateXaX_byXnameXX_name_capXaX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      
g.V(vid1).store("a").by("name").out().local(aggregate("a").by("name")).values("name").cap("a")
+      """
+    When iterated next
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+
   Scenario: g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX
     Given the modern graph
     And using the parameter xx1 defined as "s[]"
@@ -77,6 +108,28 @@ Feature: Step - store()
         cap("a")
       """
     When iterated next
+    Then the result should be unordered
+      | result |
+      | d[1].l |
+      | d[1].l |
+      | d[0].l |
+      | d[0].l |
+      | d[0].l |
+      | d[2].l |
+      | d[1.0].d |
+      | d[1.0].d |
+
+  Scenario: 
g_V_localXaggregateXaX_byXoutEXcreatedX_countX_out_out_localXaggregateXaX_byXinEXcreatedX_weight_sumXX_capXaX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().local(aggregate("a").
+             by(__.outE("created").count())).
+        out().out().local(aggregate("a").
+                      by(__.inE("created").values("weight").sum())).
+        cap("a")
+      """
+    When iterated next
     Then the result should be unordered
       | result |
       | d[1].l |

Reply via email to