You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by xi...@apache.org on 2025/09/06 00:33:15 UTC

(tinkerpop) 01/01: Merge branch '3.8-dev'

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

xiazcy pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 32dc3847323bb06766055a49cacf78c992013938
Merge: 25f0e15cda ca58a971dc
Author: xiazcy <xi...@gmail.com>
AuthorDate: Fri Sep 5 17:32:55 2025 -0700

    Merge branch '3.8-dev'

 CHANGELOG.asciidoc                                 |   1 +
 docs/src/dev/provider/gremlin-semantics.asciidoc   |  58 ++-
 docs/src/reference/the-traversal.asciidoc          |  46 +++
 docs/src/upgrade/release-3.8.x.asciidoc            |  63 ++++
 .../tinkerpop/gremlin/jsr223/CoreImports.java      |   3 +
 .../grammar/DefaultGremlinBaseVisitor.java         |  12 +
 .../language/grammar/GenericLiteralVisitor.java    |   5 +
 .../language/grammar/TraversalEnumParser.java      |  11 +
 .../language/grammar/TraversalMethodVisitor.java   |  17 +
 .../translator/GroovyTranslateVisitor.java         |   9 +
 .../language/translator/JavaTranslateVisitor.java  |  11 +
 .../translator/JavascriptTranslateVisitor.java     |   9 +
 .../language/translator/TranslateVisitor.java      |   7 +
 .../gremlin/process/traversal/GremlinLang.java     |   3 +
 .../tinkerpop/gremlin/process/traversal/N.java     |  48 +++
 .../traversal/dsl/graph/GraphTraversal.java        |  29 +-
 .../gremlin/process/traversal/dsl/graph/__.java    |  15 +
 .../process/traversal/step/map/AsNumberStep.java   | 104 ++++++
 .../gremlin/structure/io/binary/DataType.java      |   1 +
 .../io/binary/TypeSerializerRegistry.java          |   4 +
 .../structure/io/binary/types/EnumSerializer.java  |   1 +
 .../structure/io/binary/types/NSerializer.java     |  46 +++
 .../structure/io/graphson/GraphSONModule.java      |   7 +
 .../io/graphson/TraversalSerializersV2.java        |  34 ++
 .../io/graphson/TraversalSerializersV3.java        |  34 ++
 .../gremlin/structure/io/gryo/GryoVersion.java     |   5 +-
 .../tinkerpop/gremlin/util/NumberHelper.java       | 102 +++++-
 .../grammar/GeneralLiteralVisitorTest.java         |  35 ++
 .../language/translator/GremlinTranslatorTest.java |  18 +
 .../traversal/step/map/AsNumberStepTest.java       | 398 +++++++++++++++++++++
 .../tinkerpop/gremlin/util/NumberHelperTest.java   | 129 +++++++
 .../Process/Traversal/GraphTraversal.cs            |   9 +
 .../src/Gremlin.Net/Process/Traversal/N.cs         |  74 ++++
 .../src/Gremlin.Net/Process/Traversal/__.cs        |   8 +
 .../Structure/IO/GraphBinary/DataType.cs           |   1 +
 .../IO/GraphBinary/TypeSerializerRegistry.cs       |   2 +
 .../IO/GraphBinary/Types/EnumSerializer.cs         |   6 +
 .../Structure/IO/GraphSON/GraphSONReader.cs        |   1 +
 .../Structure/IO/GraphSON/NDeserializer.cs         |  38 ++
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs | 263 ++++++++------
 .../Structure/IO/GraphBinary/GraphBinaryTests.cs   |  15 +
 .../Structure/IO/GraphSON/GraphSONReaderTests.cs   |  12 +
 .../Structure/IO/GraphSON/GraphSONWriterTests.cs   |  11 +
 gremlin-go/driver/anonymousTraversal.go            |   5 +
 gremlin-go/driver/cucumber/gremlin.go              | 259 ++++++++------
 gremlin-go/driver/graphBinary.go                   |   3 +
 gremlin-go/driver/graphTraversal.go                |   6 +
 gremlin-go/driver/serializer.go                    |   2 +
 gremlin-go/driver/traversal.go                     |  36 +-
 gremlin-javascript/build/generate.groovy           |   1 +
 .../lib/process/graph-traversal.ts                 |  10 +
 .../gremlin-javascript/lib/process/traversal.ts    |   1 +
 .../lib/structure/io/binary/internals/DataType.js  |   1 +
 .../io/binary/internals/EnumSerializer.js          |   2 +
 .../gremlin-javascript/test/cucumber/gremlin.js    |  25 ++
 .../test/unit/graphbinary/AnySerializer-test.js    |  11 +-
 .../test/unit/graphbinary/EnumSerializer-test.js   |   3 +-
 gremlin-language/src/main/antlr4/Gremlin.g4        |  38 ++
 .../language/corpus/DocumentationReader.java       |   4 +-
 gremlin-python/build/generate.groovy               |   2 +-
 .../gremlin_python/process/graph_traversal.py      |  14 +
 .../python/gremlin_python/process/traversal.py     |  11 +
 .../gremlin_python/structure/io/graphbinaryV4.py   |   8 +-
 gremlin-python/src/main/python/radish/gremlin.py   |  26 +-
 .../gremlin/test/features/map/AsNumber.feature     | 303 ++++++++++++++++
 65 files changed, 2209 insertions(+), 267 deletions(-)

diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java
index 5b4c96295e,e894f8bf24..0ce7a44cba
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java
@@@ -19,12 -19,9 +19,13 @@@
  package org.apache.tinkerpop.gremlin.language.grammar;
  
  import org.antlr.v4.runtime.tree.ParseTree;
+ import org.apache.tinkerpop.gremlin.process.traversal.N;
  import org.apache.tinkerpop.gremlin.process.traversal.Scope;
 +import org.apache.tinkerpop.gremlin.structure.Column;
  import org.apache.tinkerpop.gremlin.structure.Direction;
 +import org.apache.tinkerpop.gremlin.structure.T;
 +
 +import java.util.function.Function;
  
  /**
   * Traversal enum parser parses all the enums like (e.g. {@link Scope} in graph traversal.
@@@ -70,13 -67,13 +71,23 @@@ public class TraversalEnumParser 
          return Direction.directionValueOf(text);
      }
  
 +    public static Function parseTraversalFunctionFromContext(final GremlinParser.TraversalFunctionContext context) {
 +        if (context.traversalT() != null) {
 +            return TraversalEnumParser.parseTraversalEnumFromContext(T.class, context.traversalT());
 +        } else if (context.traversalColumn() != null)
 +            return TraversalEnumParser.parseTraversalEnumFromContext(Column.class, context.traversalColumn());
 +        else {
 +            throw new GremlinParserException("Unrecognized enum for traversal function");
 +        }
 +    }
++
+     /**
+      * Parsing of {@link N} requires some special handling because of java keyword collision.
+      */
+     public static N parseTraversalNFromContext(final GremlinParser.TraversalNContext context) {
+         String text = context.getText();
+         if (text.startsWith(N.class.getSimpleName()))
+             text = text.substring(N.class.getSimpleName().length() + 1);
+         return text.startsWith("big") ? N.valueOf(text) : N.valueOf(text + "_");
+     }
  }
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java
index 54038e925a,0000000000..3ec2494766
mode 100644,000000..100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java
@@@ -1,516 -1,0 +1,519 @@@
 +/*
 + *  Licensed to the Apache Software Foundation (ASF) under one
 + *  or more contributor license agreements.  See the NOTICE file
 + *  distributed with this work for additional information
 + *  regarding copyright ownership.  The ASF licenses this file
 + *  to you under the Apache License, Version 2.0 (the
 + *  "License"); you may not use this file except in compliance
 + *  with the License.  You may obtain a copy of the License at
 + *
 + *  http://www.apache.org/licenses/LICENSE-2.0
 + *
 + *  Unless required by applicable law or agreed to in writing,
 + *  software distributed under the License is distributed on an
 + *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 + *  KIND, either express or implied.  See the License for the
 + *  specific language governing permissions and limitations
 + *  under the License.
 + */
 +
 +package org.apache.tinkerpop.gremlin.process.traversal;
 +
 +import org.apache.commons.configuration2.Configuration;
 +import org.apache.commons.text.StringEscapeUtils;
 +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 +import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 +import org.apache.tinkerpop.gremlin.process.traversal.strategy.TraversalStrategyProxy;
 +import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
 +import org.apache.tinkerpop.gremlin.process.traversal.util.ConnectiveP;
 +import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversal;
 +import org.apache.tinkerpop.gremlin.structure.Column;
 +import org.apache.tinkerpop.gremlin.structure.T;
 +import org.apache.tinkerpop.gremlin.structure.Vertex;
 +import org.apache.tinkerpop.gremlin.util.NumberHelper;
 +
 +import javax.lang.model.SourceVersion;
 +import java.io.Serializable;
 +import java.math.BigDecimal;
 +import java.math.BigInteger;
 +import java.time.OffsetDateTime;
 +import java.util.ArrayList;
 +import java.util.HashMap;
 +import java.util.Iterator;
 +import java.util.LinkedHashMap;
 +import java.util.LinkedHashSet;
 +import java.util.List;
 +import java.util.Map;
 +import java.util.Objects;
 +import java.util.Set;
 +import java.util.concurrent.atomic.AtomicInteger;
 +
 +import static org.apache.tinkerpop.gremlin.util.DatetimeHelper.format;
 +import static org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils.asIterator;
 +
 +/**
 + * This class helps to build a gremlin-lang compatible string representation based on a {@link TraversalSource}
 + * and then a {@link Traversal}.
 + */
 +public class GremlinLang implements Cloneable, Serializable {
 +
 +    private static final Object[] EMPTY_ARRAY = new Object[]{};
 +
 +    private StringBuilder gremlin = new StringBuilder();
 +    private Map<String, Object> parameters = new HashMap<>();
 +    private static final AtomicInteger paramCount = new AtomicInteger(0);
 +    private List<OptionsStrategy> optionsStrategies = new ArrayList<>();
 +
 +    public GremlinLang() {
 +    }
 +
 +    public GremlinLang(final String sourceName, final Object... arguments) {
 +        addToGremlin(sourceName, arguments);
 +    }
 +
 +    private void addToGremlin(final String name, final Object... arguments) {
 +        final Object[] flattenedArguments = flattenArguments(arguments);
 +
 +        // todo: figure out solution for AbstractLambdaTraversal
 +        if ("CardinalityValueTraversal".equals(name)) {
 +            gremlin.append("Cardinality.").append(flattenedArguments[0])
 +                    .append("(").append(flattenedArguments[1]).append(")");
 +            return;
 +        }
 +
 +        gremlin.append(".").append(name).append('(');
 +
 +        for (int i = 0; i < flattenedArguments.length; i++) {
 +            if (i != 0) {
 +                gremlin.append(',');
 +            }
 +            gremlin.append(argAsString(flattenedArguments[i]));
 +        }
 +
 +        gremlin.append(')');
 +    }
 +
 +    private String argAsString(final Object arg) {
 +        if (arg == null)
 +            return "null";
 +
 +        if (arg instanceof String)
 +            return String.format("\"%s\"", StringEscapeUtils.escapeJava((String) arg));
 +        if (arg instanceof Boolean)
 +            return arg.toString();
 +
 +        if (arg instanceof Byte)
 +            return String.format("%sB", arg);
 +        if (arg instanceof Short)
 +            return String.format("%sS", arg);
 +        if (arg instanceof Integer)
 +            return arg.toString();
 +        if (arg instanceof Long)
 +            return String.format("%sL", arg);
 +
 +        if (arg instanceof BigInteger)
 +            return String.format("%sN", arg);
 +        if (arg instanceof Float) {
 +            if (NumberHelper.isNaN(arg))
 +                return "NaN";
 +            if (NumberHelper.isPositiveInfinity(arg))
 +                return "+Infinity";
 +            if (NumberHelper.isNegativeInfinity(arg))
 +                return "-Infinity";
 +
 +            return String.format("%sF", arg);
 +        }
 +        if (arg instanceof Double) {
 +            if (NumberHelper.isNaN(arg))
 +                return "NaN";
 +            if (NumberHelper.isPositiveInfinity(arg))
 +                return "+Infinity";
 +            if (NumberHelper.isNegativeInfinity(arg))
 +                return "-Infinity";
 +            return String.format("%sD", arg);
 +        }
 +        if (arg instanceof BigDecimal)
 +            return String.format("%sM", arg);
 +
 +        if (arg instanceof OffsetDateTime)
 +            return String.format("datetime(\"%s\")", format(((OffsetDateTime) arg).toInstant()));
 +
 +        if (arg instanceof Enum) {
 +            // special handling for enums with additional interfaces
 +            if (arg instanceof T)
 +                return String.format("T.%s", arg);
++            if (arg instanceof N) {
++                return String.format("N.%s", arg).replace("_","");
++            }
 +            if (arg instanceof Order)
 +                return String.format("Order.%s", arg);
 +            if (arg instanceof Column)
 +                return String.format("Column.%s", arg);
 +            if (arg instanceof Operator)
 +                return String.format("Operator.%s", arg);
 +            if (arg instanceof SackFunctions.Barrier)
 +                return String.format("Barrier.%s", arg);
 +
 +            return String.format("%s.%s", arg.getClass().getSimpleName(), arg);
 +        }
 +
 +        if (arg instanceof Vertex)
 +            return argAsString(((Vertex) arg).id());
 +
 +        if (arg instanceof P) {
 +            return asString((P<?>) arg);
 +        }
 +
 +        if (arg instanceof GremlinLang || arg instanceof DefaultTraversal) {
 +            final GremlinLang gremlinLang = arg instanceof GremlinLang ? (GremlinLang) arg : ((DefaultTraversal) arg).getGremlinLang();
 +            parameters.putAll(gremlinLang.getParameters());
 +            return gremlinLang.getGremlin("__");
 +        }
 +
 +        if (arg instanceof GValue) {
 +            final GValue gValue = (GValue) arg;
 +            String key = gValue.getName();
 +
 +            if (key == null) {
 +                return argAsString(((GValue<?>) arg).get());
 +            }
 +
 +            if (!SourceVersion.isIdentifier(key)) {
 +                throw new IllegalArgumentException(String.format("Invalid parameter name [%s].", key));
 +            }
 +
 +            if (parameters.containsKey(key)) {
 +                if (!Objects.equals(parameters.get(key), gValue.get())) {
 +                    throw new IllegalArgumentException(String.format("Parameter with name [%s] already defined.", key));
 +                }
 +            } else {
 +                parameters.put(key, gValue.get());
 +            }
 +            return key;
 +        }
 +
 +        if (arg instanceof Map) {
 +            return asString((Map) arg);
 +        }
 +
 +        if (arg instanceof Set) {
 +            return asString((Set) arg);
 +        }
 +
 +        // handle all iterables in similar way
 +        if (arg instanceof List || arg instanceof Object[] || arg.getClass().isArray()) {
 +            return asString(asIterator(arg));
 +        }
 +
 +        if (arg instanceof Class) {
 +            return ((Class) arg).getSimpleName();
 +        }
 +
 +        return asParameter(arg);
 +    }
 +
 +    private String asParameter(final Object arg) {
 +        final String paramName = String.format("_%d", paramCount.getAndIncrement());
 +        // todo: consider resetting paramCount when it's larger then 1_000_000
 +        parameters.put(paramName, arg);
 +        return paramName;
 +    }
 +
 +    private String asString(final Iterator itty) {
 +        final StringBuilder sb = new StringBuilder().append("[");
 +
 +        while (itty.hasNext()) {
 +            sb.append(argAsString(itty.next()));
 +            if (itty.hasNext())
 +                sb.append(",");
 +        }
 +
 +        return sb.append("]").toString();
 +    }
 +
 +    private String asString(final Set<?> set) {
 +        final StringBuilder sb = new StringBuilder().append("{");
 +
 +        final Iterator itty = asIterator(set);
 +
 +        while (itty.hasNext()) {
 +            sb.append(argAsString(itty.next()));
 +            if (itty.hasNext())
 +                sb.append(",");
 +        }
 +
 +        return sb.append("}").toString();
 +    }
 +
 +    // borrowed from Groovy translator
 +    private String asString(final P<?> p) {
 +        final StringBuilder sb = new StringBuilder();
 +        if (p instanceof TextP) {
 +            sb.append("TextP.").append(p.getPredicateName()).append("(");
 +            sb.append(argAsString(p.getValue()));
 +        } else if (p instanceof ConnectiveP) {
 +            // ConnectiveP gets some special handling because it's reduced to and(P, P, P) and we want it
 +            // generated the way it was written which was P.and(P).and(P)
 +            final List<P<?>> list = ((ConnectiveP) p).getPredicates();
 +            final String connector = p.getPredicateName();
 +            for (int i = 0; i < list.size(); i++) {
 +                sb.append(argAsString(list.get(i)));
 +
 +                // for the first/last P there is no parent to close
 +                if (i > 0 && i < list.size() - 1) sb.append(")");
 +
 +                // add teh connector for all but last P
 +                if (i < list.size() - 1) {
 +                    sb.append(".").append(connector).append("(");
 +                }
 +            }
 +        } else {
 +            sb.append("P.").append(p.getPredicateName()).append("(");
 +            sb.append(argAsString(p.getValue()));
 +        }
 +        sb.append(")");
 +        return sb.toString();
 +    }
 +
 +    private String asString(final Map<?, ?> map) {
 +        final StringBuilder sb = new StringBuilder("[");
 +        int size = map.size();
 +
 +        if (size == 0) {
 +            sb.append(":");
 +        } else {
 +            for (Map.Entry<?, ?> entry : map.entrySet()) {
 +                String key = argAsString(entry.getKey());
 +                // special handling for non-string keys
 +                if (entry.getKey() instanceof Enum && key.contains(".")) {
 +                    key = String.format("(%s)", key);
 +                }
 +
 +                sb.append(key).append(":").append(argAsString(entry.getValue()));
 +                if (--size > 0) {
 +                    sb.append(',');
 +                }
 +            }
 +        }
 +
 +        sb.append("]");
 +        return sb.toString();
 +    }
 +
 +    /**
 +     * Get gremlin-lang compatible representation of Traversal
 +     * @return gremlin-lang compatible String
 +     */
 +    public String getGremlin() {
 +        return getGremlin("g");
 +    }
 +
 +    /**
 +     * Get gremlin-lang compatible representation of Traversal.
 +     * "g" is expected for gremlin-lang.
 +     * "__" can be used for an anonymous {@link GraphTraversal}.
 +     *
 +     * @param g GraphTraversalSource name
 +     * @return gremlin-lang compatible String
 +     */
 +    public String getGremlin(final String g) {
 +        // special handling for CardinalityValueTraversal
 +        if (gremlin.length() != 0 && gremlin.charAt(0) != '.') {
 +            return gremlin.toString();
 +        }
 +        return g + gremlin;
 +    }
 +
 +    /**
 +     * Get parameters used in Traversal.
 +     *
 +     * @return parameters Map
 +     */
 +    public Map<String, Object> getParameters() {
 +        return parameters;
 +    }
 +
 +    /**
 +     * The alias to set.
 +     */
 +    public void addG(final String g) {
 +        parameters.put("g", g);
 +    }
 +
 +    /**
 +    * Reset parameter naming counter. Mainly intended to make testing easier
 +    */
 +    public void reset() {
 +        paramCount.set(0);
 +    }
 +
 +    /**
 +     * Add a {@link TraversalSource} instruction to the GremlinLang.
 +     *
 +     * @param sourceName the traversal source method name (e.g. withSack())
 +     * @param arguments  the traversal source method arguments
 +     */
 +    public void addSource(final String sourceName, final Object... arguments) {
 +        if (sourceName.equals(TraversalSource.Symbols.withStrategies) && arguments.length != 0) {
 +            final String args =  buildStrategyArgs(arguments);
 +
 +            // possible to have empty strategies list to send
 +            if (!args.isEmpty()) {
 +                gremlin.append('.').append(TraversalSource.Symbols.withStrategies).append('(').append(args).append(')');
 +            }
 +            return;
 +        }
 +
 +        addToGremlin(sourceName, arguments);
 +    }
 +
 +    private String buildStrategyArgs(final Object[] arguments) {
 +        final StringBuilder sb = new StringBuilder();
 +        for (int i = 0; i < arguments.length; i++) {
 +            // special handling for OptionsStrategy
 +            if (arguments[i] instanceof OptionsStrategy) {
 +                optionsStrategies.add((OptionsStrategy) arguments[i]);
 +                break;
 +            }
 +
 +            Configuration configuration;
 +            String strategyName;
 +
 +            // special handling for TraversalStrategyProxy
 +            if (arguments[i] instanceof TraversalStrategyProxy) {
 +                configuration = ((TraversalStrategy) arguments[i]).getConfiguration();
 +                strategyName = ((TraversalStrategyProxy) arguments[i]).getStrategyName();
 +            } else {
 +                configuration = ((TraversalStrategy) arguments[i]).getConfiguration();
 +                strategyName = arguments[i].getClass().getSimpleName();
 +            }
 +
 +            if (configuration.isEmpty()) {
 +                sb.append(strategyName);
 +            } else {
 +                sb.append("new ")
 +                        .append(strategyName)
 +                        .append("(");
 +
 +                configuration.getKeys().forEachRemaining(key -> {
 +                    if (!key.equals("strategy")) {
 +                        sb.append(key).append(":").append(argAsString(configuration.getProperty(key))).append(",");
 +                    }
 +                });
 +                // remove last comma
 +                if (sb.lastIndexOf(",") == sb.length() - 1) {
 +                    sb.setLength(sb.length() - 1);
 +                }
 +
 +                sb.append(')');
 +            }
 +
 +            if (i != arguments.length - 1)
 +                sb.append(',');
 +        }
 +
 +        return sb.toString();
 +    }
 +
 +    /**
 +     * Add a {@link Traversal} instruction to the GremlinLang.
 +     *
 +     * @param stepName  the traversal method name (e.g. out())
 +     * @param arguments the traversal method arguments
 +     */
 +    public void addStep(final String stepName, final Object... arguments) {
 +        addToGremlin(stepName, arguments);
 +    }
 +
 +    /**
 +     * Provides a way to get configuration of a Traversal.
 +     *
 +     * @return list of OptionsStrategy
 +     */
 +    public List<OptionsStrategy> getOptionsStrategies() {
 +        return optionsStrategies;
 +    }
 +
 +    public boolean isEmpty() {
 +        return this.gremlin.length() == 0;
 +    }
 +
 +    @Override
 +    public String toString() {
 +        return gremlin.toString();
 +    }
 +
 +    // todo: clarify equality with parameters
 +    @Override
 +    public boolean equals(Object o) {
 +        if (this == o) return true;
 +        if (o == null || getClass() != o.getClass()) return false;
 +        final GremlinLang gremlinLang = (GremlinLang) o;
 +        return Objects.equals(gremlin.toString(), gremlinLang.gremlin.toString()) &&
 +                Objects.equals(parameters, gremlinLang.parameters);
 +    }
 +
 +    @Override
 +    public int hashCode() {
 +        return Objects.hash(gremlin, parameters);
 +    }
 +
 +    @Override
 +    public GremlinLang clone() {
 +        try {
 +            final GremlinLang clone = (GremlinLang) super.clone();
 +            clone.parameters = new HashMap<>(parameters);
 +            clone.gremlin = new StringBuilder(gremlin.length());
 +            clone.gremlin.append(gremlin);
 +            clone.optionsStrategies = new ArrayList<>(this.optionsStrategies);
 +            return clone;
 +        } catch (final CloneNotSupportedException e) {
 +            throw new IllegalStateException(e.getMessage(), e);
 +        }
 +    }
 +
 +    private Object[] flattenArguments(final Object... arguments) {
 +        if (arguments == null || arguments.length == 0)
 +            return EMPTY_ARRAY;
 +        final List<Object> flatArguments = new ArrayList<>(arguments.length);
 +        for (final Object object : arguments) {
 +            if (object instanceof Object[]) {
 +                for (final Object nestObject : (Object[]) object) {
 +                    flatArguments.add(convertArgument(nestObject));
 +                }
 +            } else
 +                flatArguments.add(convertArgument(object));
 +        }
 +        return flatArguments.toArray();
 +    }
 +
 +    private Object convertArgument(final Object argument) {
 +        if (argument instanceof Traversal) {
 +            // prevent use of "g" to spawn child traversals
 +            if (((Traversal) argument).asAdmin().getTraversalSource().isPresent())
 +                throw new IllegalStateException(String.format(
 +                        "The child traversal of %s was not spawned anonymously - use the __ class rather than a TraversalSource to construct the child traversal", argument));
 +
 +            return ((Traversal) argument).asAdmin().getGremlinLang();
 +        } else if (argument instanceof Map) {
 +            final Map<Object, Object> map = new LinkedHashMap<>(((Map) argument).size());
 +            for (final Map.Entry<?, ?> entry : ((Map<?, ?>) argument).entrySet()) {
 +                map.put(convertArgument(entry.getKey()), convertArgument(entry.getValue()));
 +            }
 +            return map;
 +        } else if (argument instanceof List) {
 +            final List<Object> list = new ArrayList<>(((List) argument).size());
 +            for (final Object item : (List) argument) {
 +                list.add(convertArgument(item));
 +            }
 +            return list;
 +        } else if (argument instanceof Set) {
 +            final Set<Object> set = new LinkedHashSet<>(((Set) argument).size());
 +            for (final Object item : (Set) argument) {
 +                set.add(convertArgument(item));
 +            }
 +            return set;
 +        } else
 +            return argument;
 +    }
 +}
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
index 10ca8ec8fe,b7d50b6680..9cbdc569e0
--- 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
@@@ -2285,6 -2308,30 +2287,30 @@@ public interface GraphTraversal<S, E> e
          return this.asAdmin().addStep(new AsDateStep<>(this.asAdmin()));
      }
  
+     /**
+      * Parse value of the incoming traverser as a {@link Number}.
+      *
+      * @return the traversal with an appended {@link AsNumberStep}.
+      * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#AsNumberStep-step" target="_blank">Reference Documentation - AsNumberStep Step</a>
+      * @since 3.8.0
+      */
+     public default GraphTraversal<S, Number> asNumber() {
 -        this.asAdmin().getBytecode().addStep(Symbols.asNumber);
++        this.asAdmin().getGremlinLang().addStep(Symbols.asNumber);
+         return this.asAdmin().addStep(new AsNumberStep<>(this.asAdmin()));
+     }
+ 
+     /**
+      * Parse value of the incoming traverser as a {@link Number}.
+      *
+      * @return the traversal with an appended {@link AsNumberStep}.
+      * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#AsNumberStep-step" target="_blank">Reference Documentation - AsNumberStep Step</a>
+      * @since 3.8.0
+      */
+     public default GraphTraversal<S, Number> asNumber(final N numberToken) {
 -        this.asAdmin().getBytecode().addStep(Symbols.asNumber, numberToken);
++        this.asAdmin().getGremlinLang().addStep(Symbols.asNumber, numberToken);
+         return this.asAdmin().addStep(new AsNumberStep<>(this.asAdmin(), numberToken));
+     }
+ 
      /**
       * Increase value of input {@link OffsetDateTime}.
       *
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/DataType.java
index 5e7cddde8c,c0738a3496..e2522c03c3
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/DataType.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/DataType.java
@@@ -51,8 -64,15 +51,9 @@@ public enum DataType 
      BYTEBUFFER(0X25),
      SHORT(0X26),
      BOOLEAN(0x27),
 -    TEXTP(0x28),
 -    TRAVERSALSTRATEGY(0X29),
 -    BULKSET(0X2A),
 +    BULKSET(0X2A),  // todo:
      TREE(0X2B),
 -    METRICS(0x2C),
 -    TRAVERSALMETRICS(0x2D),
 -    MERGE(0x2E),
 -    DT(0x2F),
+     N(0x30),
  
      CHAR(0X80),
      DURATION(0X81),
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java
index 5eb09365e0,56a85b590b..ec81398393
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java
@@@ -18,12 -18,29 +18,13 @@@
   */
  package org.apache.tinkerpop.gremlin.structure.io.binary;
  
 -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
 -import org.apache.tinkerpop.gremlin.process.traversal.DT;
  import org.apache.tinkerpop.gremlin.process.traversal.Merge;
 -import org.apache.tinkerpop.gremlin.process.traversal.N;
 -import org.apache.tinkerpop.gremlin.process.traversal.Operator;
 -import org.apache.tinkerpop.gremlin.process.traversal.Order;
 -import org.apache.tinkerpop.gremlin.process.traversal.P;
  import org.apache.tinkerpop.gremlin.process.traversal.Path;
 -import org.apache.tinkerpop.gremlin.process.traversal.Pick;
 -import org.apache.tinkerpop.gremlin.process.traversal.Pop;
 -import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
 -import org.apache.tinkerpop.gremlin.process.traversal.Scope;
 -import org.apache.tinkerpop.gremlin.process.traversal.TextP;
 -import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
  import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
++import org.apache.tinkerpop.gremlin.process.traversal.N;
  import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet;
  import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
 -import org.apache.tinkerpop.gremlin.process.traversal.util.AndP;
 -import org.apache.tinkerpop.gremlin.process.traversal.util.Metrics;
 -import org.apache.tinkerpop.gremlin.process.traversal.util.OrP;
  import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation;
 -import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMetrics;
 -import org.apache.tinkerpop.gremlin.structure.Column;
  import org.apache.tinkerpop.gremlin.structure.Direction;
  import org.apache.tinkerpop.gremlin.structure.Edge;
  import org.apache.tinkerpop.gremlin.structure.Graph;
@@@ -42,11 -63,23 +43,13 @@@ import org.apache.tinkerpop.gremlin.str
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.EdgeSerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.EnumSerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.GraphSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.InetAddressSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.InstantSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.LambdaSerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.ListSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.LocalDateSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.LocalDateTimeSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.LocalTimeSerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.MapEntrySerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.MapSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.MetricsSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.MonthDaySerializer;
 +import org.apache.tinkerpop.gremlin.structure.io.binary.types.DateTimeSerializer;
+ import org.apache.tinkerpop.gremlin.structure.io.binary.types.NSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.OffsetDateTimeSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.OffsetTimeSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.PSerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.PathSerializer;
 -import org.apache.tinkerpop.gremlin.structure.io.binary.types.PeriodSerializer;
++import org.apache.tinkerpop.gremlin.process.traversal.N;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.PropertySerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.SetSerializer;
  import org.apache.tinkerpop.gremlin.structure.io.binary.types.SingleTypeSerializer;
@@@ -102,9 -160,28 +105,10 @@@ public class TypeSerializerRegistry 
              new RegistryEntry<>(Property.class, new PropertySerializer()),
              new RegistryEntry<>(Graph.class, new GraphSerializer()),
              new RegistryEntry<>(Vertex.class, new VertexSerializer()),
 -            new RegistryEntry<>(SackFunctions.Barrier.class, EnumSerializer.BarrierSerializer),
 -            new RegistryEntry<>(Bytecode.Binding.class, new BindingSerializer()),
 -            new RegistryEntry<>(Bytecode.class, new ByteCodeSerializer()),
 -            new RegistryEntry<>(VertexProperty.Cardinality.class, EnumSerializer.CardinalitySerializer),
 -            new RegistryEntry<>(Column.class, EnumSerializer.ColumnSerializer),
              new RegistryEntry<>(Direction.class, EnumSerializer.DirectionSerializer),
 -            new RegistryEntry<>(DT.class, EnumSerializer.DTSerializer),
 -            new RegistryEntry<>(Merge.class, EnumSerializer.MergeSerializer),
 -            new RegistryEntry<>(N.class, new NSerializer()),
 -            new RegistryEntry<>(Operator.class, EnumSerializer.OperatorSerializer),
 -            new RegistryEntry<>(Order.class, EnumSerializer.OrderSerializer),
 -            new RegistryEntry<>(Pick.class, EnumSerializer.PickSerializer),
 -            new RegistryEntry<>(Pop.class, EnumSerializer.PopSerializer),
 -            new RegistryEntry<>(Lambda.class, new LambdaSerializer()),
 -            new RegistryEntry<>(P.class, new PSerializer<>(DataType.P, P.class)),
 -            new RegistryEntry<>(AndP.class, new PSerializer<>(DataType.P, AndP.class)),
 -            new RegistryEntry<>(OrP.class, new PSerializer<>(DataType.P, OrP.class)),
 -            new RegistryEntry<>(TextP.class, new PSerializer<>(DataType.TEXTP, TextP.class)),
 -            new RegistryEntry<>(Scope.class, EnumSerializer.ScopeSerializer),
              new RegistryEntry<>(T.class, EnumSerializer.TSerializer),
 -            new RegistryEntry<>(Traverser.class, new TraverserSerializer()),
              new RegistryEntry<>(Merge.class, EnumSerializer.MergeSerializer),
++            new RegistryEntry<>(N.class, new NSerializer()),
              new RegistryEntry<>(BigDecimal.class, new BigDecimalSerializer()),
              new RegistryEntry<>(BigInteger.class, new BigIntegerSerializer()),
              new RegistryEntry<>(Byte.class, SingleTypeSerializer.ByteSerializer),
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
index 06396d8dff,b40d029a98..469224f13e
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
@@@ -19,9 -19,14 +19,10 @@@
  package org.apache.tinkerpop.gremlin.structure.io.graphson;
  
  import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration.VertexProgramStrategy;
 -import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.finalization.ComputerFinalizationStrategy;
  import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.GraphFilterStrategy;
 -import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.MessagePassingReductionStrategy;
 -import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.verification.VertexProgramRestrictionStrategy;
 -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
  import org.apache.tinkerpop.gremlin.process.traversal.DT;
  import org.apache.tinkerpop.gremlin.process.traversal.Merge;
+ import org.apache.tinkerpop.gremlin.process.traversal.N;
  import org.apache.tinkerpop.gremlin.process.traversal.Operator;
  import org.apache.tinkerpop.gremlin.process.traversal.Order;
  import org.apache.tinkerpop.gremlin.process.traversal.P;
@@@ -396,8 -286,10 +398,9 @@@ abstract class GraphSONModule extends T
                      Scope.class,
                      Pick.class,
                      T.class).forEach(e -> addSerializer(e, new TraversalSerializersV3.EnumJacksonSerializer()));
+             addSerializer(N.class, new TraversalSerializersV3.NJacksonSerializer());
              addSerializer(P.class, new TraversalSerializersV3.PJacksonSerializer());
              addSerializer(Lambda.class, new TraversalSerializersV3.LambdaJacksonSerializer());
 -            addSerializer(Bytecode.Binding.class, new TraversalSerializersV3.BindingJacksonSerializer());
              addSerializer(Traverser.class, new TraversalSerializersV3.TraverserJacksonSerializer());
              addSerializer(TraversalStrategy.class, new TraversalSerializersV3.TraversalStrategyJacksonSerializer());
  
@@@ -634,8 -543,10 +639,9 @@@
                      Scope.class,
                      Pick.class,
                      T.class).forEach(e -> addSerializer(e, new TraversalSerializersV2.EnumJacksonSerializer()));
+             addSerializer(N.class, new TraversalSerializersV2.NJacksonSerializer());
              addSerializer(P.class, new TraversalSerializersV2.PJacksonSerializer());
              addSerializer(Lambda.class, new TraversalSerializersV2.LambdaJacksonSerializer());
 -            addSerializer(Bytecode.Binding.class, new TraversalSerializersV2.BindingJacksonSerializer());
              addSerializer(Traverser.class, new TraversalSerializersV2.TraverserJacksonSerializer());
              addSerializer(TraversalStrategy.class, new TraversalSerializersV2.TraversalStrategyJacksonSerializer());
  
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java
index 756b53f0c2,8141bbeaba..290c1a2ff5
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java
@@@ -22,6 -22,8 +22,7 @@@ package org.apache.tinkerpop.gremlin.st
  import org.apache.commons.configuration2.BaseConfiguration;
  import org.apache.commons.configuration2.ConfigurationConverter;
  import org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser;
 -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
+ import org.apache.tinkerpop.gremlin.process.traversal.N;
  import org.apache.tinkerpop.gremlin.process.traversal.P;
  import org.apache.tinkerpop.gremlin.process.traversal.TextP;
  import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java
index 1c8b55e9b9,daf3b14d7c..8183c310ad
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java
@@@ -22,6 -22,8 +22,7 @@@ package org.apache.tinkerpop.gremlin.st
  import org.apache.commons.configuration2.BaseConfiguration;
  import org.apache.commons.configuration2.ConfigurationConverter;
  import org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser;
 -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
+ import org.apache.tinkerpop.gremlin.process.traversal.N;
  import org.apache.tinkerpop.gremlin.process.traversal.P;
  import org.apache.tinkerpop.gremlin.process.traversal.TextP;
  import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/gryo/GryoVersion.java
index 723f469fa9,e96cb6429c..c6687ff379
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/gryo/GryoVersion.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/gryo/GryoVersion.java
@@@ -646,8 -645,7 +648,9 @@@ public enum GryoVersion 
              add(GryoTypeReg.of(Stack.class, 181));
              add(GryoTypeReg.of(ReferenceMap.class, 182));
  
 -            add(GryoTypeReg.of(GValue.class, 199, new JavaSerializer()));       // ***LAST ID***
 +            add(GryoTypeReg.of(GValue.class, 199, new JavaSerializer()));
-             add(GryoTypeReg.of(GType.class, 200, new JavaSerializer()));        // ***LAST ID***
++            // GType should be removed to match 3.8 GValue implementation, changing ID for now
++            add(GryoTypeReg.of(GType.class, 205, new JavaSerializer()));        // ***LAST ID***
          }};
      }
  
diff --cc gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
index 769250903a,0e64184cc8..3d5da0ac72
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
@@@ -750,15 -741,24 +750,33 @@@ public class GremlinTranslatorTest 
                              null,
                              null,
                              "g.inject(long(1694017707000)).as_date()"},
+                     {"g.inject(\"123.4\").asNumber(N.int)",
+                             null,
+                             "g.inject(string0).asNumber(N.int)",
+                             "g.Inject<object>(\"123.4\").AsNumber(N.Int)",
+                             "g.Inject(\"123.4\").AsNumber(gremlingo.N.Int)",
+                             "g.inject(\"123.4\").asNumber(N.int_)",
+                             "g.inject(\"123.4\").asNumber(N.int_)",
+                             "g.inject(\"123.4\").asNumber(N.int_)",
+                             "g.inject('123.4').as_number(N.int)"},
+                     {"g.inject(\"123.4\").asNumber(N.bigInt)",
+                             null,
+                             "g.inject(string0).asNumber(N.bigInt)",
+                             "g.Inject<object>(\"123.4\").AsNumber(N.BigInt)",
+                             "g.Inject(\"123.4\").AsNumber(gremlingo.N.BigInt)",
+                             "g.inject(\"123.4\").asNumber(N.bigInt)",
+                             "g.inject(\"123.4\").asNumber(N.bigInt)",
+                             "g.inject(\"123.4\").asNumber(N.bigInt)",
+                             "g.inject('123.4').as_number(N.big_int)"},
 +                    {"g.inject(null, null).inject(null, null)",
 +                            null,
 +                            "g.inject(object0, object0).inject(object0, object0)",
 +                            "g.Inject<object>(null, null).Inject(null, null)",
 +                            "g.Inject(nil, nil).Inject(nil, nil)",
 +                            "g.inject(null, (Object) null).inject(null, (Object) null)",
 +                            "g.inject(null, null).inject(null, null)",
 +                            "g.inject(null, null).inject(null, null)",
 +                            "g.inject(None, None).inject(None, None)"},
                      {"g.V().hasLabel(null)",
                              null,
                              "g.V().hasLabel(string0)",
diff --cc gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index 2ab833ef97,5c9e723904..50b8c60f0c
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@@ -175,13 -176,13 +175,13 @@@ namespace Gremlin.Net.IntegrationTest.G
                 {"g_V_valuesXageX_order_byXdescX_fold_allXgtX10XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Fold().All(P.Gt(10))}}, 
                 {"g_V_valuesXageX_order_byXdescX_fold_allXgtX30XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Fold().All(P.Gt(30))}}, 
                 {"g_injectXabc_bcdX_allXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "abc", "bcd" }).All(P.Eq("bcd"))}}, 
-                {"g_injectXbcd_bcdX_allXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(P.Eq("bcd"))}}, 
-                {"g_injectXnull_abcX_allXTextP_startingWithXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(TextP.StartingWith("a"))}}, 
-                {"g_injectX5_8_10_10_7X_allXgteX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).All(P.Gte(7))}}, 
 -               {"g_injectXbcd_bcdX_allXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "bcd", "bcd" }).All(P.Eq("bcd"))}}, 
 -               {"g_injectXnull_abcX_allXTextP_startingWithXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { null, "abc" }).All(TextP.StartingWith("a"))}}, 
 -               {"g_injectX5_8_10_10_7X_allXgteX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 5, 8, 10 }, new List<object> { 10, 7 }).All(P.Gte(7))}}, 
++               {"g_injectXbcd_bcdX_allXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(P.Eq("bcd"))}},
++               {"g_injectXnull_abcX_allXTextP_startingWithXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(TextP.StartingWith("a"))}},
++               {"g_injectX5_8_10_10_7X_allXgteX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).All(P.Gte(7))}},
                 {"g_injectXnullX_allXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).All(P.Eq(null))}}, 
                 {"g_injectX7X_allXeqX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(7).All(P.Eq(7))}}, 
-                {"g_injectXnull_nullX_allXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(P.Eq(null))}}, 
-                {"g_injectX3_threeX_allXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(P.Eq(3))}}, 
 -               {"g_injectXnull_nullX_allXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { null, null }).All(P.Eq(null))}}, 
 -               {"g_injectX3_threeX_allXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).All(P.Eq(3))}}, 
++               {"g_injectXnull_nullX_allXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(P.Eq(null))}},
++               {"g_injectX3_threeX_allXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).All(P.Eq(3))}},
                 {"g_V_andXhasXage_gt_27X__outE_count_gte_2X_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().And(__.Has("age", P.Gt(27)), __.OutE().Count().Is(P.Gte(2))).Values<object>("name")}}, 
                 {"g_V_andXoutE__hasXlabel_personX_and_hasXage_gte_32XX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().And(__.OutE(), __.Has(T.Label, "person").And().Has("age", P.Gte(32))).Values<object>("name")}}, 
                 {"g_V_asXaX_outXknowsX_and_outXcreatedX_inXcreatedX_asXaX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("a").Out("knows").And().Out("created").In("created").As("a").Values<object>("name")}}, 
@@@ -192,16 -193,15 +192,16 @@@
                 {"g_V_valuesXageX_order_byXdescX_fold_anyXgtX10XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Fold().Any(P.Gt(10))}}, 
                 {"g_V_valuesXageX_order_byXdescX_fold_anyXgtX42XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Fold().Any(P.Gt(42))}}, 
                 {"g_injectXabc_cdeX_anyXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "abc", "cde" }).Any(P.Eq("bcd"))}}, 
-                {"g_injectXabc_bcdX_anyXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(P.Eq("bcd"))}}, 
-                {"g_injectXnull_abcX_anyXTextP_startingWithXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(TextP.StartingWith("a"))}}, 
-                {"g_injectX5_8_10_10_7X_anyXeqX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).Any(P.Eq(7))}}, 
 -               {"g_injectXabc_bcdX_anyXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "abc", "bcd" }).Any(P.Eq("bcd"))}}, 
 -               {"g_injectXnull_abcX_anyXTextP_startingWithXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { null, "abc" }).Any(TextP.StartingWith("a"))}}, 
 -               {"g_injectX5_8_10_10_7X_anyXeqX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 5, 8, 10 }, new List<object> { 10, 7 }).Any(P.Eq(7))}}, 
++               {"g_injectXabc_bcdX_anyXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(P.Eq("bcd"))}},
++               {"g_injectXnull_abcX_anyXTextP_startingWithXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(TextP.StartingWith("a"))}},
++               {"g_injectX5_8_10_10_7X_anyXeqX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).Any(P.Eq(7))}},
                 {"g_injectXnullX_anyXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).Any(P.Eq(null))}}, 
                 {"g_injectX7X_anyXeqX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(7).Any(P.Eq(7))}}, 
-                {"g_injectXnull_nullX_anyXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(P.Eq(null))}}, 
-                {"g_injectX3_threeX_anyXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(P.Eq(3))}}, 
 -               {"g_injectXnull_nullX_anyXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { null, null }).Any(P.Eq(null))}}, 
 -               {"g_injectX3_threeX_anyXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).Any(P.Eq(3))}}, 
++               {"g_injectXnull_nullX_anyXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(P.Eq(null))}},
++               {"g_injectX3_threeX_anyXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Any(P.Eq(3))}},
                 {"g_V_coinX1X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Coin(1.0)}}, 
-                {"g_V_coinX1varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Coin(p["xx1"])}}, 
--               {"g_V_coinX0X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Coin(0.0)}}, 
++               {"g_V_coinX1varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Coin(p["xx1"])}},
++               {"g_V_coinX0X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Coin(0.0)}},
                 {"g_withStrategiesXSeedStrategyX_V_order_byXnameX_coinX50X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new SeedStrategy(seed: 999999)).V().Order().By("name").Coin(0.5)}}, 
                 {"g_VX1X_outXcreatedX_inXcreatedX_cyclicPath", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out("created").In("created").CyclicPath()}}, 
                 {"g_VX1X_both_both_cyclicPath_byXageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Both().Both().CyclicPath().By("age")}}, 
@@@ -321,8 -321,7 +321,8 @@@
                 {"g_V_hasIdXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(P.Eq(null))}}, 
                 {"g_V_hasIdX2_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid2"], null)}}, 
                 {"g_V_hasIdXmarkovar_vadasvarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid1"], p["vid2"])}}, 
-                {"g_V_hasIdXmarkovar_vadasvar_petervarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid1"], p["vid2"])}}, 
--               {"g_V_hasIdX2AsString_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid2"], null)}}, 
++               {"g_V_hasIdXmarkovar_vadasvar_petervarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid1"], p["vid2"])}},
++               {"g_V_hasIdX2AsString_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid2"], null)}},
                 {"g_V_hasIdX1AsString_2AsString_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid1"], p["vid2"], null)}}, 
                 {"g_V_hasIdXnull_2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(null, p["vid2"])}}, 
                 {"g_V_hasIdX1X_hasIdX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasId(p["vid1"]).HasId(p["vid2"])}}, 
@@@ -377,14 -376,14 +377,14 @@@
                 {"g_V_valuesXageX_order_byXdescX_fold_noneXltX10XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Fold().None(P.Lt(10))}}, 
                 {"g_V_valuesXageX_order_byXdescX_fold_noneXgtX30XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Fold().None(P.Gt(30))}}, 
                 {"g_injectXabc_bcdX_noneXeqXbcdXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "abc", "bcd" }).None(P.Eq("bcd"))}}, 
-                {"g_injectXbcd_bcdX_noneXeqXabcXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Eq("abc"))}}, 
-                {"g_injectXnull_bcdX_noneXP_eqXabcXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Eq("abc"))}}, 
-                {"g_injectX5_8_10_10_7X_noneXltX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).None(P.Lt(7))}}, 
 -               {"g_injectXbcd_bcdX_noneXeqXabcXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "bcd", "bcd" }).None(P.Eq("abc"))}}, 
 -               {"g_injectXnull_bcdX_noneXP_eqXabcXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { null, "bcd" }).None(P.Eq("abc"))}}, 
 -               {"g_injectX5_8_10_10_7X_noneXltX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 5, 8, 10 }, new List<object> { 10, 7 }).None(P.Lt(7))}}, 
++               {"g_injectXbcd_bcdX_noneXeqXabcXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Eq("abc"))}},
++               {"g_injectXnull_bcdX_noneXP_eqXabcXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Eq("abc"))}},
++               {"g_injectX5_8_10_10_7X_noneXltX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).None(P.Lt(7))}},
                 {"g_injectXnullX_noneXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).None(P.Eq(null))}}, 
                 {"g_injectX7X_noneXeqX7XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(7).None(P.Eq(7))}}, 
-                {"g_injectXnull_1_emptyX_noneXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).None(P.Eq(null))}}, 
-                {"g_injectXnull_nullX_noneXnotXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Neq(null))}}, 
-                {"g_injectX3_threeX_noneXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Eq(3))}}, 
 -               {"g_injectXnull_1_emptyX_noneXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { null, 1 }, new List<object> {  }).None(P.Eq(null))}}, 
 -               {"g_injectXnull_nullX_noneXnotXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { null, null }).None(P.Neq(null))}}, 
 -               {"g_injectX3_threeX_noneXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).None(P.Eq(3))}}, 
++               {"g_injectXnull_1_emptyX_noneXeqXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).None(P.Eq(null))}},
++               {"g_injectXnull_nullX_noneXnotXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Neq(null))}},
++               {"g_injectX3_threeX_noneXeqX3XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).None(P.Eq(3))}},
                 {"g_V_orXhasXage_gt_27X__outE_count_gte_2X_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Or(__.Has("age", P.Gt(27)), __.OutE().Count().Is(P.Gte(2))).Values<object>("name")}}, 
                 {"g_V_orXoutEXknowsX__hasXlabel_softwareX_or_hasXage_gte_35XX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Or(__.OutE("knows"), __.Has(T.Label, "software").Or().Has("age", P.Gte(35))).Values<object>("name")}}, 
                 {"g_V_asXaX_orXselectXaX_selectXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("a").Or(__.Select<object>("a"), __.Select<object>("a"))}}, 
@@@ -713,23 -712,47 +713,52 @@@
                 {"g_injectXmixed_trueX_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("tRUe").AsBool()}}, 
                 {"g_injectXnullX_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).AsBool()}}, 
                 {"g_injectXhelloX_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("hello").AsBool()}}, 
-                {"g_injectX1_2X_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsBool()}}, 
 -               {"g_injectX1_2X_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2 }).AsBool()}}, 
++               {"g_injectX1_2X_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsBool()}},
                 {"g_VXX_localX_outE_countX_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Local<object>(__.OutE().Count()).AsBool()}}, 
                 {"g_V_sackXassignX_byX_hasLabelXpersonX_count_asBoolX_sackXandX_byX_outE_count_asBoolX_sack_path", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Sack(Operator.Assign).By(__.HasLabel("person").Count().AsBool()).Sack(Operator.And).By(__.OutE().Count().AsBool()).Sack<object>().Path()}}, 
                 {"g_injectXstrX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("2023-08-02T00:00:00Z").AsDate()}}, 
                 {"g_injectXstr_offsetX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("2023-08-02T00:00:00-07:00").AsDate()}}, 
                 {"g_injectX1694017707000X_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1694017707000).AsDate()}}, 
-                {"g_injectX1694017708000LX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsDate()}}, 
-                {"g_injectX1694017709000dX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsDate()}}, 
-                {"g_injectX1_2X_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsDate()}}, 
 -               {"g_injectX1694017708000LX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1694017708000l).AsDate()}}, 
 -               {"g_injectX1694017709000dX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1694017709000.1d).AsDate()}}, 
 -               {"g_injectX1_2X_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2 }).AsDate()}}, 
++               {"g_injectX1694017708000LX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsDate()}},
++               {"g_injectX1694017709000dX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsDate()}},
++               {"g_injectX1_2X_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsDate()}},
                 {"g_injectXnullX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).AsDate()}}, 
                 {"g_injectXinvalidstrX_asDate", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("This String is not an ISO 8601 Date").AsDate()}}, 
-                {"g_injectX1_2X_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).AsString()}}, 
-                {"g_injectX1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).AsString<object>(Scope.Local)}}, 
-                {"g_injectXlist_1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsString<object>(Scope.Local)}}, 
-                {"g_injectX1_nullX_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null, p["xx1"]).AsString()}}, 
-                {"g_injectX1_nullX_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsString<object>(Scope.Local)}}, 
 -               {"g_injectX5bX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>((byte) 5).AsNumber()}}, 
 -               {"g_injectX5sX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>((short) 5).AsNumber()}}, 
 -               {"g_injectX5iX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5).AsNumber()}}, 
 -               {"g_injectX5lX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5l).AsNumber()}}, 
 -               {"g_injectX5nX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new BigInteger(5)).AsNumber()}}, 
 -               {"g_injectX5_0X_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.0).AsNumber()}}, 
 -               {"g_injectX5_75fX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.75f).AsNumber()}}, 
 -               {"g_injectX5_43X_asNumberXN_intX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.43).AsNumber(N.Int)}}, 
 -               {"g_injectX5_67X_asNumberXN_intX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.67).AsNumber(N.Int)}}, 
 -               {"g_injectX5X_asNumberXN_longX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5).AsNumber(N.Long)}}, 
 -               {"g_injectX12X_asNumberXN_byteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(12).AsNumber(N.Byte)}}, 
 -               {"g_injectX32768X_asNumberXN_shortX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(32768).AsNumber(N.Short)}}, 
 -               {"g_injectX300X_asNumberXN_byteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(300).AsNumber(N.Byte)}}, 
 -               {"g_injectX5X_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("5").AsNumber()}}, 
 -               {"g_injectX5X_asNumberXN_byteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("5").AsNumber(N.Byte)}}, 
 -               {"g_injectX1_000X_asNumberXN_bigIntX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("1,000").AsNumber(N.BigInt)}}, 
 -               {"g_injectXtestX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("test").AsNumber()}}, 
 -               {"g_injectX_1_2_3_4X_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2, 3, 4 }).AsNumber()}}, 
 -               {"g_injectX1_2_3_4X_unfold_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2, 3, 4 }).Unfold<object>().AsNumber()}}, 
 -               {"g_injectX_1__2__3__4_X_asNumberXX_foldXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("1", 2, "3", 4).AsNumber().Fold()}}, 
 -               {"g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1.0, 2, 3, "4", "0x5").AsNumber().Sum<object>().AsNumber(N.Byte)}}, 
 -               {"g_injectXnullX_asNumberXN_intX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).AsNumber(N.Int)}}, 
 -               {"g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("a").Out("knows").As("b").Math("a + b").By("age").AsNumber(N.Int)}}, 
 -               {"g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSideEffect("x", 100).V().Values<object>("age").Math("_ + x").AsNumber(N.Long)}}, 
 -               {"g_injectX1_2X_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1, 2).AsString()}}, 
 -               {"g_injectX1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1, 2).AsString<object>(Scope.Local)}}, 
 -               {"g_injectXlist_1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2 }).AsString<object>(Scope.Local)}}, 
 -               {"g_injectX1_nullX_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null, 1).AsString()}}, 
 -               {"g_injectX1_nullX_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, null }).AsString<object>(Scope.Local)}}, 
--               {"g_V_valueMapXnameX_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("name").AsString()}}, 
++               {"g_injectX1_2X_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).AsString()}},
++               {"g_injectX1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).AsString<object>(Scope.Local)}},
++               {"g_injectXlist_1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsString<object>(Scope.Local)}},
++               {"g_injectX1_nullX_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null, p["xx1"]).AsString()}},
++               {"g_injectX1_nullX_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).AsString<object>(Scope.Local)}},
++               {"g_injectX5bX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>((byte) 5).AsNumber()}},
++               {"g_injectX5sX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>((short) 5).AsNumber()}},
++               {"g_injectX5iX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5).AsNumber()}},
++               {"g_injectX5lX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5l).AsNumber()}},
++               {"g_injectX5nX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new BigInteger(5)).AsNumber()}},
++               {"g_injectX5_0X_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.0).AsNumber()}},
++               {"g_injectX5_75fX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.75f).AsNumber()}},
++               {"g_injectX5_43X_asNumberXN_intX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.43).AsNumber(N.Int)}},
++               {"g_injectX5_67X_asNumberXN_intX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.67).AsNumber(N.Int)}},
++               {"g_injectX5X_asNumberXN_longX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5).AsNumber(N.Long)}},
++               {"g_injectX12X_asNumberXN_byteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(12).AsNumber(N.Byte)}},
++               {"g_injectX32768X_asNumberXN_shortX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(32768).AsNumber(N.Short)}},
++               {"g_injectX300X_asNumberXN_byteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(300).AsNumber(N.Byte)}},
++               {"g_injectX5X_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("5").AsNumber()}},
++               {"g_injectX5X_asNumberXN_byteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("5").AsNumber(N.Byte)}},
++               {"g_injectX1_000X_asNumberXN_bigIntX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("1,000").AsNumber(N.BigInt)}},
++               {"g_injectXtestX_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("test").AsNumber()}},
++               {"g_injectX_1_2_3_4X_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2, 3, 4 }).AsNumber()}},
++               {"g_injectX1_2_3_4X_unfold_asNumber", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2, 3, 4 }).Unfold<object>().AsNumber()}},
++               {"g_injectX_1__2__3__4_X_asNumberXX_foldXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("1", 2, "3", 4).AsNumber().Fold()}},
++               {"g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1.0, 2, 3, "4", "0x5").AsNumber().Sum<object>().AsNumber(N.Byte)}},
++               {"g_injectXnullX_asNumberXN_intX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).AsNumber(N.Int)}},
++               {"g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("a").Out("knows").As("b").Math("a + b").By("age").AsNumber(N.Int)}},
++               {"g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSideEffect("x", 100).V().Values<object>("age").Math("_ + x").AsNumber(N.Long)}},
++               {"g_injectX1_2X_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1, 2).AsString()}},
++               {"g_injectX1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1, 2).AsString<object>(Scope.Local)}},
++               {"g_injectXlist_1_2X_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2 }).AsString<object>(Scope.Local)}},
++               {"g_injectX1_nullX_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null, 1).AsString()}},
++               {"g_injectX1_nullX_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, null }).AsString<object>(Scope.Local)}},
++               {"g_V_valueMapXnameX_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("name").AsString()}},
                 {"g_V_valueMapXnameX_order_fold_asStringXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("name").Order().Fold().AsString<object>(Scope.Local)}}, 
                 {"g_V_asString", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().AsString()}}, 
                 {"g_V_fold_asStringXlocalX_orderXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().AsString<object>(Scope.Local).Order(Scope.Local)}}, 
@@@ -769,20 -792,19 +798,20 @@@
                 {"g_V_fold_combineXconstantXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Combine(__.Constant<object>(null))}}, 
                 {"g_V_fold_combineXVX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Combine(__.V())}}, 
                 {"g_V_valuesXnameX_fold_combineX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Combine(2)}}, 
-                {"g_V_valuesXnameX_fold_combineX2varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Combine(p["xx1"])}}, 
--               {"g_V_valuesXnameX_fold_combineXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Combine(null)}}, 
++               {"g_V_valuesXnameX_fold_combineX2varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Combine(p["xx1"])}},
++               {"g_V_valuesXnameX_fold_combineXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Combine(null)}},
                 {"g_V_valuesXnonexistantX_fold_combineXV_valuesXnameX_foldX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("nonexistant").Fold().Combine(__.V().Values<object>("name").Fold()).Unfold<object>()}}, 
                 {"g_V_valuesXnameX_fold_combineXV_valuesXnonexistantX_foldX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Combine(__.V().Values<object>("nonexistant").Fold()).Unfold<object>()}}, 
                 {"g_V_valuesXageX_order_byXdescX_fold_combineXV_valuesXageX_order_byXdescX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Fold().Combine(__.V().Values<object>("age").Order().By(Order.Desc).Fold())}}, 
-                {"g_V_out_path_byXvaluesXnameX_toUpperX_combineXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Combine(p["xx1"])}}, 
-                {"g_injectXxx1X_combineXV_valuesXnameX_foldX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(__.V().Values<object>("name").Fold()).Unfold<object>()}}, 
-                {"g_V_valueMapXlocationX_selectXvaluesX_unfold_combineXseattle_vancouverX_orderXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Combine(p["xx1"]).Order(Scope.Local)}}, 
-                {"g_V_out_out_path_byXnameX_combineXempty_listX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Combine(p["xx1"])}}, 
 -               {"g_V_out_path_byXvaluesXnameX_toUpperX_combineXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Combine(new List<object> { "MARKO" })}}, 
 -               {"g_injectXxx1X_combineXV_valuesXnameX_foldX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "marko" }).Combine(__.V().Values<object>("name").Fold()).Unfold<object>()}}, 
 -               {"g_V_valueMapXlocationX_selectXvaluesX_unfold_combineXseattle_vancouverX_orderXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Combine(new List<object> { "seattle", "vancouver" }).Order(Scope.Local)}}, 
 -               {"g_V_out_out_path_byXnameX_combineXempty_listX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Combine(new List<object> {  })}}, 
++               {"g_V_out_path_byXvaluesXnameX_toUpperX_combineXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Combine(p["xx1"])}},
++               {"g_injectXxx1X_combineXV_valuesXnameX_foldX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(__.V().Values<object>("name").Fold()).Unfold<object>()}},
++               {"g_V_valueMapXlocationX_selectXvaluesX_unfold_combineXseattle_vancouverX_orderXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Combine(p["xx1"]).Order(Scope.Local)}},
++               {"g_V_out_out_path_byXnameX_combineXempty_listX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Combine(p["xx1"])}},
                 {"g_V_valuesXageX_order_fold_combineXconstantX27X_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().Fold().Combine(__.Constant<object>(27).Fold())}}, 
-                {"g_V_out_out_path_byXnameX_combineXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Combine(p["xx1"])}}, 
-                {"g_injectXa_null_bX_combineXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(p["xx2"])}}, 
-                {"g_injectXa_null_bX_combineXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(p["xx2"])}}, 
-                {"g_injectX3_threeX_combineXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(p["xx2"])}}, 
 -               {"g_V_out_out_path_byXnameX_combineXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Combine(new List<object> { "dave", "kelvin" })}}, 
 -               {"g_injectXa_null_bX_combineXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Combine(new List<object> { "a", "c" })}}, 
 -               {"g_injectXa_null_bX_combineXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Combine(new List<object> { "a", null, "c" })}}, 
 -               {"g_injectX3_threeX_combineXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).Combine(new List<object> { "five", "three", 7 })}}, 
++               {"g_V_out_out_path_byXnameX_combineXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Combine(p["xx1"])}},
++               {"g_injectXa_null_bX_combineXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(p["xx2"])}},
++               {"g_injectXa_null_bX_combineXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(p["xx2"])}},
++               {"g_injectX3_threeX_combineXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Combine(p["xx2"])}},
                 {"g_injectXa_bX_concat", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("a", "b").Concat()}}, 
                 {"g_injectXa_bX_concat_XcX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("a", "b").Concat("c")}}, 
                 {"g_injectXa_bX_concat_Xc_dX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("a", "b").Concat("c", "d")}}, 
@@@ -802,8 -824,7 +831,8 @@@
                 {"g_V_valuesXnameX_conjoinX1X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Conjoin((string) "1")}}, 
                 {"g_V_valuesXnonexistantX_fold_conjoinX_X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("nonexistant").Fold().Conjoin((string) ";")}}, 
                 {"g_V_valuesXnameX_order_fold_conjoinX_X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Order().Fold().Conjoin((string) "_")}}, 
-                {"g_V_valuesXageX_order_fold_conjoinXsemicolonX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().Fold().Conjoin((string) ";")}}, 
-                {"g_V_valuesXageX_order_fold_conjoinXslashX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().Fold().Conjoin((string) p["xx1"])}}, 
 -               {"g_V_valuesXageX_order_fold_conjoinX_X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().Fold().Conjoin((string) ";")}}, 
++               {"g_V_valuesXageX_order_fold_conjoinXsemicolonX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().Fold().Conjoin((string) ";")}},
++               {"g_V_valuesXageX_order_fold_conjoinXslashX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().Fold().Conjoin((string) p["xx1"])}},
                 {"g_V_out_path_byXvaluesXnameX_toUpperX_conjoinXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Conjoin((string) "MARKO")}}, 
                 {"g_injectXmarkoX_conjoinX_X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "marko" }).Conjoin((string) "-")}}, 
                 {"g_V_valueMapXlocationX_selectXvaluesX_unfold_orderXlocalX_conjoinX1X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Order(Scope.Local).Conjoin((string) "1")}}, 
@@@ -846,8 -867,7 +875,8 @@@
                 {"g_V_fold_differenceXconstantXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Difference(__.Constant<object>(null))}}, 
                 {"g_V_fold_differenceXVX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Difference(__.V())}}, 
                 {"g_V_valuesXnameX_fold_differenceX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Difference(2)}}, 
-                {"g_V_valuesXnameX_fold_differenceX2varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Difference(p["xx1"])}}, 
--               {"g_V_valuesXnameX_fold_differenceXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Difference(null)}}, 
++               {"g_V_valuesXnameX_fold_differenceX2varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Difference(p["xx1"])}},
++               {"g_V_valuesXnameX_fold_differenceXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Difference(null)}},
                 {"g_V_valuesXnonexistantX_fold_differenceXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("nonexistant").Fold().Difference(__.V().Values<object>("name").Fold())}}, 
                 {"g_V_valuesXnameX_fold_differenceXV_valuesXnonexistantX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Difference(__.V().Values<object>("nonexistant").Fold())}}, 
                 {"g_V_valuesXageX_fold_differenceXV_valuesXageX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold().Difference(__.V().Values<object>("age").Fold())}}, 
@@@ -858,16 -878,15 +887,16 @@@
                 {"g_V_out_out_path_byXnameX_differenceXempty_listX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Difference(new List<object> {  })}}, 
                 {"g_V_valuesXageX_fold_differenceXconstantX27X_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold().Difference(__.Constant<object>(27).Fold())}}, 
                 {"g_V_out_out_path_byXnameX_differenceXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Difference(new List<object> { "dave", "kelvin" })}}, 
-                {"g_injectXa_null_bX_differenceXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Difference(p["xx2"])}}, 
-                {"g_injectXa_null_bX_differenceXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Difference(p["xx2"])}}, 
-                {"g_injectX3_threeX_differenceXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Difference(p["xx2"])}}, 
 -               {"g_injectXa_null_bX_differenceXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Difference(new List<object> { "a", "c" })}}, 
 -               {"g_injectXa_null_bX_differenceXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Difference(new List<object> { "a", null, "c" })}}, 
 -               {"g_injectX3_threeX_differenceXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).Difference(new List<object> { "five", "three", 7 })}}, 
++               {"g_injectXa_null_bX_differenceXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Difference(p["xx2"])}},
++               {"g_injectXa_null_bX_differenceXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Difference(p["xx2"])}},
++               {"g_injectX3_threeX_differenceXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Difference(p["xx2"])}},
                 {"g_injectXnullX_disjunctXinjectX1XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).Disjunct(__.Inject(1))}}, 
                 {"g_V_valuesXnameX_disjunctXV_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Disjunct(__.V().Fold())}}, 
                 {"g_V_fold_disjunctXconstantXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Disjunct(__.Constant<object>(null))}}, 
                 {"g_V_fold_disjunctXVX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Disjunct(__.V())}}, 
                 {"g_V_valuesXnameX_fold_disjunctX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Disjunct(2)}}, 
-                {"g_V_valuesXnameX_fold_disjunctX3varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Disjunct(p["xx1"])}}, 
--               {"g_V_valuesXnameX_fold_disjunctXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Disjunct(null)}}, 
++               {"g_V_valuesXnameX_fold_disjunctX3varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Disjunct(p["xx1"])}},
++               {"g_V_valuesXnameX_fold_disjunctXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Disjunct(null)}},
                 {"g_V_valuesXnonexistantX_fold_disjunctXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("nonexistant").Fold().Disjunct(__.V().Values<object>("name").Fold())}}, 
                 {"g_V_valuesXnameX_fold_disjunctXV_valuesXnonexistantX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Disjunct(__.V().Values<object>("nonexistant").Fold())}}, 
                 {"g_V_valuesXageX_fold_disjunctXV_valuesXageX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold().Disjunct(__.V().Values<object>("age").Fold())}}, 
@@@ -905,8 -924,7 +934,8 @@@
                 {"g_VX1X_outEXknows_createdX_inV", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE("knows", "created").InV()}}, 
                 {"g_VX1X_outEXknowsX_bothV", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE("knows").BothV()}}, 
                 {"g_VX1X_outEXknowsX_bothV_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE("knows").BothV().Values<object>("name")}}, 
-                {"g_V_toEXout_knowsvarX_valuesXweightX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ToE(Direction.Out, p["xx1"]).Values<object>("weight")}}, 
--               {"g_VX1X_properties_element", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid2"]).Properties<object>().Element().Limit<object>(1)}}, 
++               {"g_V_toEXout_knowsvarX_valuesXweightX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ToE(Direction.Out, p["xx1"]).Values<object>("weight")}},
++               {"g_VX1X_properties_element", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid2"]).Properties<object>().Element().Limit<object>(1)}},
                 {"g_V_properties_element", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Properties<object>().Element()}}, 
                 {"g_V_propertiesXageX_element", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Properties<object>("age").Element()}}, 
                 {"g_EX_properties_element", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"]).Properties<object>().Element().Limit<object>(1)}}, 
@@@ -945,24 -963,23 +974,24 @@@
                 {"g_V_fold_intersectXconstantXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Intersect(__.Constant<object>(null))}}, 
                 {"g_V_fold_intersectXVX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Intersect(__.V())}}, 
                 {"g_V_valuesXnameX_fold_intersectX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Intersect(2)}}, 
-                {"g_V_valuesXnameX_fold_intersectX5varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Intersect(p["xx1"])}}, 
--               {"g_V_valuesXnameX_fold_intersectXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Intersect(null)}}, 
++               {"g_V_valuesXnameX_fold_intersectX5varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Intersect(p["xx1"])}},
++               {"g_V_valuesXnameX_fold_intersectXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Intersect(null)}},
                 {"g_V_valuesXnonexistantX_fold_intersectXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("nonexistant").Fold().Intersect(__.V().Values<object>("name").Fold())}}, 
                 {"g_V_valuesXnameX_fold_intersectXV_valuesXnonexistantX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Intersect(__.V().Values<object>("nonexistant").Fold())}}, 
                 {"g_V_valuesXageX_fold_intersectXV_valuesXageX_foldX_order_local", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold().Intersect(__.V().Values<object>("age").Fold()).Order(Scope.Local)}}, 
                 {"g_V_out_path_byXvaluesXnameX_toUpperX_intersectXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Intersect(new List<object> { "MARKO" })}}, 
-                {"g_injectXmarkoX_intersectX___V_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(__.V().Values<object>("name").Fold())}}, 
-                {"g_V_valueMapXlocationX_selectXvaluesX_unfold_intersectXseattle_vancouverX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Intersect(p["xx1"])}}, 
 -               {"g_injectXmarkoX_intersectX___V_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "marko" }).Intersect(__.V().Values<object>("name").Fold())}}, 
 -               {"g_V_valueMapXlocationX_selectXvaluesX_unfold_intersectXseattle_vancouverX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Intersect(new List<object> { "seattle", "vancouver" })}}, 
++               {"g_injectXmarkoX_intersectX___V_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(__.V().Values<object>("name").Fold())}},
++               {"g_V_valueMapXlocationX_selectXvaluesX_unfold_intersectXseattle_vancouverX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Intersect(p["xx1"])}},
                 {"g_V_valuesXageX_fold_intersectX___constantX27X_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold().Intersect(__.Constant<object>(27).Fold())}}, 
-                {"g_V_out_out_path_byXnameX_intersectXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Intersect(p["xx1"])}}, 
-                {"g_injectXa_null_bX_intersectXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(p["xx2"])}}, 
-                {"g_injectXa_null_bX_intersectXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(p["xx2"])}}, 
-                {"g_injectX3_threeX_intersectXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(p["xx2"])}}, 
 -               {"g_V_out_out_path_byXnameX_intersectXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Intersect(new List<object> { "dave", "kelvin" })}}, 
 -               {"g_injectXa_null_bX_intersectXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Intersect(new List<object> { "a", "c" })}}, 
 -               {"g_injectXa_null_bX_intersectXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Intersect(new List<object> { "a", null, "c" })}}, 
 -               {"g_injectX3_threeX_intersectXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).Intersect(new List<object> { "five", "three", 7 })}}, 
++               {"g_V_out_out_path_byXnameX_intersectXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Intersect(p["xx1"])}},
++               {"g_injectXa_null_bX_intersectXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(p["xx2"])}},
++               {"g_injectXa_null_bX_intersectXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(p["xx2"])}},
++               {"g_injectX3_threeX_intersectXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Intersect(p["xx2"])}},
                 {"g_injectX__feature___test__nullX_lTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("  feature", " one test", null, "", " ", " abc", "abc ", " abc ", "  ").LTrim()}}, 
                 {"g_injectX__feature___test__nullX_lTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "  feature  ", " one test ", null, "", " ", " abc", "abc ", " abc ", "  " }).LTrim<object>(Scope.Local)}}, 
                 {"g_injectX__feature__X_lTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("  feature  ").LTrim()}}, 
-                {"g_injectXListXa_bXX_lTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).LTrim()}}, 
-                {"g_injectXListX1_2XX_lTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).LTrim<object>(Scope.Local)}}, 
 -               {"g_injectXListXa_bXX_lTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", "b" }).LTrim()}}, 
 -               {"g_injectXListX1_2XX_lTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2 }).LTrim<object>(Scope.Local)}}, 
++               {"g_injectXListXa_bXX_lTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).LTrim()}},
++               {"g_injectXListX1_2XX_lTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).LTrim<object>(Scope.Local)}},
                 {"g_V_valuesXnameX_lTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   ripple   ").Propert [...]
                 {"g_V_valuesXnameX_order_fold_lTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   r [...]
                 {"g_injectXfeature_test_nullX_length", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("feature", "test", null).Length()}}, 
@@@ -1073,16 -1090,16 +1102,16 @@@
                 {"g_V_valuesXnonexistantX_fold_mergeXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("nonexistant").Fold().Merge(__.V().Values<object>("name").Fold())}}, 
                 {"g_V_valuesXnameX_fold_mergeXV_valuesXnonexistantX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Merge(__.V().Values<object>("nonexistant").Fold())}}, 
                 {"g_V_valuesXageX_fold_mergeXV_valuesXageX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold().Merge(__.V().Values<object>("age").Fold())}}, 
-                {"g_V_out_path_byXvaluesXnameX_toUpperX_mergeXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Merge(p["xx1"])}}, 
-                {"g_injectXmarkoX_mergeXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(__.V().Values<object>("name").Fold())}}, 
-                {"g_V_valueMapXlocationX_selectXvaluesX_unfold_mergeXseattle_vancouverX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Merge(p["xx1"])}}, 
-                {"g_V_out_out_path_byXnameX_mergeXempty_listX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Merge(p["xx1"])}}, 
 -               {"g_V_out_path_byXvaluesXnameX_toUpperX_mergeXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Merge(new List<object> { "MARKO" })}}, 
 -               {"g_injectXmarkoX_mergeXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "marko" }).Merge(__.V().Values<object>("name").Fold())}}, 
 -               {"g_V_valueMapXlocationX_selectXvaluesX_unfold_mergeXseattle_vancouverX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Merge(new List<object> { "seattle", "vancouver" })}}, 
 -               {"g_V_out_out_path_byXnameX_mergeXempty_listX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Merge(new List<object> {  })}}, 
++               {"g_V_out_path_byXvaluesXnameX_toUpperX_mergeXMARKOX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Path().By(__.Values<object>("name").ToUpper()).Merge(p["xx1"])}},
++               {"g_injectXmarkoX_mergeXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(__.V().Values<object>("name").Fold())}},
++               {"g_V_valueMapXlocationX_selectXvaluesX_unfold_mergeXseattle_vancouverX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>("location").Select<object>(Column.Values).Unfold<object>().Merge(p["xx1"])}},
++               {"g_V_out_out_path_byXnameX_mergeXempty_listX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Merge(p["xx1"])}},
                 {"g_V_valuesXageX_fold_mergeXconstantX27X_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold().Merge(__.Constant<object>(27).Fold())}}, 
-                {"g_V_out_out_path_byXnameX_mergeXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Merge(p["xx1"])}}, 
-                {"g_injectXa_null_bX_mergeXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(p["xx2"])}}, 
-                {"g_injectXa_null_bX_mergeXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(p["xx2"])}}, 
-                {"g_injectX3_threeX_mergeXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(p["xx2"])}}, 
-                {"g_V_asXnameX_projectXnameX_byXnameX_mergeXother_blueprintX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("name").Project<object>("name").By("name").Merge(p["xx1"])}}, 
 -               {"g_V_out_out_path_byXnameX_mergeXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Merge(new List<object> { "dave", "kelvin" })}}, 
 -               {"g_injectXa_null_bX_mergeXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Merge(new List<object> { "a", "c" })}}, 
 -               {"g_injectXa_null_bX_mergeXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", null, "b" }).Merge(new List<object> { "a", null, "c" })}}, 
 -               {"g_injectX3_threeX_mergeXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).Merge(new List<object> { "five", "three", 7 })}}, 
 -               {"g_V_asXnameX_projectXnameX_byXnameX_mergeXother_blueprintX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("name").Project<object>("name").By("name").Merge(new Dictionary<object, object> {{ "other", "blueprint" }})}}, 
++               {"g_V_out_out_path_byXnameX_mergeXdave_kelvinX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Path().By("name").Merge(p["xx1"])}},
++               {"g_injectXa_null_bX_mergeXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(p["xx2"])}},
++               {"g_injectXa_null_bX_mergeXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(p["xx2"])}},
++               {"g_injectX3_threeX_mergeXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Merge(p["xx2"])}},
++               {"g_V_asXnameX_projectXnameX_byXnameX_mergeXother_blueprintX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("name").Project<object>("name").By("name").Merge(p["xx1"])}},
                 {"g_V_hasXname_markoX_elementMap_mergeXV_hasXname_lopX_elementMapX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("name", "marko").ElementMap<object>().Merge(__.V().Has("name", "lop").ElementMap<object>())}}, 
                 {"g_V_mergeEXlabel_selfX_optionXonMatch_emptyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).AddE("self"), (g,p) =>g.V().MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) new Dictionary<object, object> {}), (g,p) =>g.E(), (g,p) =>g.E().Properties<object>(), (g,p) =>g.V()}}, 
                 {"g_V_mergeEXlabel_selfX_optionXonMatch_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).AddE("self"), (g,p) =>g.V().MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) null), (g,p) =>g.E(), (g,p) =>g.E().Properties<object>(), (g,p) =>g.V()}}, 
@@@ -1105,7 -1122,7 +1134,7 @@@
                 {"g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (IDictionary<object, object>) p["xx2"]).Option(Merge.OnMatch, (IDiction [...]
                 {"g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (IDictionary<object, object>) p["xx2"] [...]
                 {"g_V_hasXperson_name_marko_X_mergeEXlabel_knowsX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("a").To("b"), (g,p) =>g.V().Has("person", "name", "marko").MergeE((IDictionary<object, object [...]
-                {"g_injectXlabel_knows_out_marko_in_vadasX_mergeE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.Inject<object>(p["xx1"]).MergeE(), (g,p) =>g.V().Has("person", "name", "marko").Out("knows").Has("person", "name", "vadas")}}, 
 -               {"g_withSideEffectXlabel_knows_out_marko_in_vadasX_injectX1X_selectXmX_mergeE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.Inject<object>(1).Select<object>("m").MergeE(), (g,p) =>g.V().Has("person", "name", "marko").Out("knows").Has("person", "name", "vadas")}}, 
++               {"g_injectXlabel_knows_out_marko_in_vadasX_mergeE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.Inject<object>(p["xx1"]).MergeE(), (g,p) =>g.V().Has("person", "name", "marko").Out("knows").Has("person", "name", "vadas")}},
                 {"g_mergeEXlabel_knows_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("b").To("a").Property("created", "Y"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.O [...]
                 {"g_mergeEXlabel_knows_out_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("b").To("a").Property("created", "Y"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge. [...]
                 {"g_mergeEXout_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("b").To("a").Property("created", "Y"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (I [...]
@@@ -1114,7 -1131,7 +1143,7 @@@
                 {"g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_selectXmXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (ITraversal) __.Select<object>("c")).Option(Merge.OnMatc [...]
                 {"g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko1_in_vadas1X_optionXonCreate_selectXcXX_optionXonMatch_selectXmXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (ITraversal) __.Select<object>("c")).Option(Merge.OnMa [...]
                 {"g_mergeEXlabel_knows_out_marko_in_vadasX_aliased_direction", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]), (g,p) =>g.V().Has("person", "name", "marko").Out("knows").Has("person", "name", "vadas")}}, 
-                {"g_injectXlabel_knows_out_marko_in_vadas_label_self_out_vadas_in_vadasX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).MergeE(), (g,p) =>g.V(), (g,p) =>g.E(), (g,p) =>g.V().Has("person", "name", "marko").Out("knows").Has("person", "name", "vadas"), (g,p) =>g.V().Has("person", "name", "vadas").Out("self [...]
 -               {"g_withSideEffectXm1_label_knows_out_marko_in_vadas_m2_label_self_out_vadas_in_vadasX_unionXselectXm1X_selectXm2XX_mergeE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.Union<object>(__.Select<object>("m1"), __.Select<object>("m2")).MergeE(), (g,p) =>g.V(), (g,p) =>g.E(), (g,p) =>g.V().Has("person", "name", "marko").Out("knows").Has("pe [...]
++               {"g_injectXlabel_knows_out_marko_in_vadas_label_self_out_vadas_in_vadasX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).MergeE(), (g,p) =>g.V(), (g,p) =>g.E(), (g,p) =>g.V().Has("person", "name", "marko").Out("knows").Has("person", "name", "vadas"), (g,p) =>g.V().Has("person", "name", "vadas").Out("self [...]
                 {"g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_sideEffectXpropertiesXweightX_dropX_selectXmXX_exists", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1.0d).From("a").To("b"), (g,p) =>g.MergeE((IDictionary<object [...]
                 {"g_mergeE_with_outVinV_options_map", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OutV, (IDictionary<object, object>) p["xx2"]).Option(Merge.InV, (IDictionary<object, object>) p["xx3"]), (g,p) =>g.V(), (g,p) =>g.V().Has("name", "marko").Out("knows").Has("name", "vadas")}}, 
                 {"g_mergeE_inline_with_outVinV_options_map", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.MergeE((IDictionary<object, object>) new Dictionary<object, object> {{ Direction.Out, Merge.OutV }, { Direction.In, Merge.InV }, { T.Label, "knows" }}).Option(Merge.OutV, (IDictionary<object, object>) p["xx1"]).Option(Merge.InV, (IDictionary<object, [...]
@@@ -1129,10 -1146,10 +1158,10 @@@
                 {"g_mergeV_mergeE_combination_new_vertices", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).As("outV").MergeV((IDictionary<object, object>) p["xx2"]).As("inV").MergeE((IDictionary<object, object>) p["xx3"]).Option(Merge.OutV, (ITraversal) __.Select<object>("outV")).Option(Merge.InV, (ITraversal) __.Select<object>("inV")), (g,p) =>g.V(), (g,p) =>g.E(), (g,p) =>g.V().Has("name", "marko" [...]
                 {"g_mergeV_mergeE_combination_existing_vertices", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas"), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).As("outV").MergeV((IDictionary<object, object>) p["xx2"]).As("inV").MergeE((IDictionary<object, object>) p["xx3"]).Option(Merge.OutV, (ITraversal) __.Select<object>("outV")).Option(Merge.InV, (ITra [...]
                 {"g_V_asXvX_mergeEXxx1X_optionXMerge_onMatch_xx2X_optionXMerge_outV_selectXvXX_optionXMerge_inV_selectXvXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.V().As("v").MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]).Option(Merge.OutV, (ITraversal) __.Select<object>("v")).Option(Merge.InV, (ITraversal [...]
-                {"g_V_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b"), (g,p) =>g.V().MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (ITraversal) __.SideEffect(__.Property("w [...]
 -               {"g_V_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b"), (g,p) =>g.V().MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (ITraversal) __.SideEffect(__.Property("w [...]
++               {"g_V_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b"), (g,p) =>g.V().MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (ITraversal) __.SideEffect(__.Property("w [...]
                 {"g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b"), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (ITraversal) __.SideEffect(__.Property("weight" [...]
-                {"g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property( [...]
-                {"g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property [...]
 -               {"g_unionXselectXmX_selectXmX_constantXcreated_NXX_fold_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As [...]
 -               {"g_unionXselectXmX_selectXmX_constantXcreated_NXX_fold_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").A [...]
++               {"g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property( [...]
++               {"g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property [...]
                 {"g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_weight_nullX_allowed", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("weight", 1.0d), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.E().H [...]
                 {"g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_weight_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("weight", 1.0d), (g,p) =>g.MergeE((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.E().HasLabel( [...]
                 {"g_mergeVXemptyX_optionXonMatch_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {}).Option(Merge.OnMatch, (IDictionary<object, object>) null), (g,p) =>g.V().Has("person", "name", "marko").Has("age", 29)}}, 
@@@ -1164,13 -1181,13 +1193,13 @@@
                 {"g_withSideEffectXc_label_person_name_stephenX_withSideEffectXm_label_person_name_stephen_age_19X_injectX0X_mergeVXselectXcXX_optionXonCreate_selectXmXX_option", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(0).MergeV((ITraversal) __.Select<object>("c")).Option(Merge.OnCreate, (ITraversal) __.Select<object>("m")), (g,p) =>g.V().Has("person", " [...]
                 {"g_withSideEffectXc_label_person_name_markoX_withSideEffectXm_age_19X_injectX0X_mergeVXselectXcXX_optionXonMatch_selectXmXX_option", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(0).MergeV((ITraversal) __.Select<object>("c")).Option(Merge.OnMatch, (ITraversal) __.Select<object>("m")), (g,p) =>g.V().Has("person", "name", "marko").Has("age", 19)}}, 
                 {"g_injectX0X_mergeVXlabel_person_name_markoX_propertyXname_vadas_acl_publicX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(0).MergeV((IDictionary<object, object>) p["xx1"]).Property("name", "vadas", "acl", "public"), (g,p) =>g.V().Properties<object>("name").HasValue("vadas").Has("acl", "public")}}, 
-                {"g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeVXidentityX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).MergeV((ITraversal) __.Identity()), (g,p) =>g.V().Has("person", "name", "stephen"), (g,p) =>g.V().Has("person", "name", "marko"), (g,p) =>g.V()}}, 
-                {"g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeV", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).MergeV(), (g,p) =>g.V().Has("person", "name", "stephen"), (g,p) =>g.V().Has("person", "name", "marko"), (g,p) =>g.V()}}, 
 -               {"g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeVXidentityX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}, new Dictionary<object, object> {{ T.Label, "person" }, { "name", "stephen" }}).MergeV((ITraversal) __.Identity()), (g,p) =>g.V().Has("person", [...]
 -               {"g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeV", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}, new Dictionary<object, object> {{ T.Label, "person" }, { "name", "stephen" }}).MergeV(), (g,p) =>g.V().Has("person", "name", "stephen"), (g,p) =>g.V().H [...]
++               {"g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeVXidentityX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).MergeV((ITraversal) __.Identity()), (g,p) =>g.V().Has("person", "name", "stephen"), (g,p) =>g.V().Has("person", "name", "marko"), (g,p) =>g.V()}},
++               {"g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeV", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).MergeV(), (g,p) =>g.V().Has("person", "name", "stephen"), (g,p) =>g.V().Has("person", "name", "marko"), (g,p) =>g.V()}},
                 {"g_mergeVXlabel_person_name_stephenX_propertyXlist_name_steveX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property(Cardinality.List, "name", "stephen"), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Property(Cardinality.List, "name", "steve"), (g,p) =>g.V(), (g,p) =>g.V().Properties<object>("name").HasValue("steve"), (g,p) =>g.V().Properties<object>("name").HasValue("stephen"), (g,p) =>g.V().Proper [...]
                 {"g_mergeXlabel_person_name_vadasX_optionXonMatch_age_35X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "vadas").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V().Has("age", 35), (g,p) =>g.V()}}, 
                 {"g_V_mapXmergeXlabel_person_name_joshXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "vadas").Property("age", 29).AddV("person").Property("name", "stephen").Property("age", 27), (g,p) =>g.V().Map<object>(__.MergeV((IDictionary<object, object>) p["xx1"])), (g,p) =>g.V().Has("person", "name", "josh"), (g,p) =>g.V()}}, 
                 {"g_withSideEffectXc_label_person_name_markoX_withSideEffectXm_age_19X_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property(Cardinality.List, "age", 29).Property(Cardinality.List, "age", 31).Property(Cardinality.List, "age", 32), (g,p) =>g.MergeV((ITraversal) __.Select<object>("c")).Option(Merge.OnMatch [...]
-                {"g_withSideEffectXm_age_19X_V_hasXperson_name_markoX_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property(Cardinality.List, "age", 29).Property(Cardinality.List, "age", 31).Property(Cardinality.List, "age", 32), (g,p) =>g.V().Has("person", "name", "marko").MergeV((IDictionary<object, object>) new Dicti [...]
 -               {"g_withSideEffectXm_age_19X_V_hasXperson_name_markoX_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property(Cardinality.List, "age", 29).Property(Cardinality.List, "age", 31).Property(Cardinality.List, "age", 32), (g,p) =>g.V().Has("person", "name", "marko").MergeV((IDictionary<object, object>) new Dicti [...]
++               {"g_withSideEffectXm_age_19X_V_hasXperson_name_markoX_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property(Cardinality.List, "age", 29).Property(Cardinality.List, "age", 31).Property(Cardinality.List, "age", 32), (g,p) =>g.V().Has("person", "name", "marko").MergeV((IDictionary<object, object>) new Dicti [...]
                 {"g_mergeV_onCreate_inheritance_existing", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "mike").Property(T.Id, "1"), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.V("1").Has("person", "name", "mike")}}, 
                 {"g_mergeV_onCreate_inheritance_new_1", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.V("1").Has("person", "name", "mike")}}, 
                 {"g_mergeV_onCreate_inheritance_new_2", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnCreate, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.V("1").Has("person", "name", "mike")}}, 
@@@ -1195,10 -1212,8 +1224,10 @@@
                 {"g_mergeVXname_aliceX_optionXonCreate_age_setX81XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ "name", "alice" }, { T.Label, "person" }}).Option(Merge.OnCreate, (IDictionary<object, object>) new Dictionary<object, object> {{ "age", CardinalityValue.Set(81) }}), (g,p) =>g.V().Has("person", "name", "alice").Has("age", 81), (g,p) =>g.V().Has("person", "name" [...]
                 {"g_mergeVXname_aliceX_optionXonCreate_age_singleX81X_age_81_setX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ "name", "alice" }, { T.Label, "person" }}).Option(Merge.OnCreate, new Dictionary<object, object> {{ "age", 81 }}, Cardinality.Set), (g,p) =>g.V().Has("person", "name", "alice").Has("age", 81), (g,p) =>g.V().Has("person", "name", "alice").Has("age") [...]
                 {"g_mergeV_hidden_label_key_onMatch_matched_prohibited", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {}).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx1"])}}, 
-                {"g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV((ITraversal) __.Select<object>("m").Limit<object>(Scope.Local, 1).Unfold<object>()).Option(Merge.OnCreate,  [...]
-                {"g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV((ITraversal) __.Select<object>("m").Limit<object>(Scope.Local, 1).Unfold<object>()).Option(Merge.OnCreate, [...]
-                {"g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX_allowed", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.V().Has("person", "name", "marko").Has("age", (object) null)}}, 
-                {"g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.V().Has("person", "name", "marko").Has("age")}}, 
 -               {"g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}, new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}, new D [...]
 -               {"g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(new Dictionary<object, object> {{ T.Label, "person" }, { "name", "stephen" }}, new Dictionary<object, object> {{ T.Label, "person" }, { "name", "stephen" }},  [...]
++               {"g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV((ITraversal) __.Select<object>("m").Limit<object>(Scope.Local, 1).Unfold<object>()).Option(Merge.OnCreate,  [...]
++               {"g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV((ITraversal) __.Select<object>("m").Limit<object>(Scope.Local, 1).Unfold<object>()).Option(Merge.OnCreate, [...]
++               {"g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX_allowed", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.V().Has("person", "name", "marko").Has("age", (object) null)}},
++               {"g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29), (g,p) =>g.MergeV((IDictionary<object, object>) p["xx1"]).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx2"]), (g,p) =>g.V(), (g,p) =>g.V().Has("person", "name", "marko").Has("age")}},
                 {"g_V_age_min", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Min<object>()}}, 
                 {"g_V_foo_min", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("foo").Min<object>()}}, 
                 {"g_V_name_min", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Min<object>()}}, 
@@@ -1272,8 -1287,7 +1301,8 @@@
                 {"g_V_fold_productXconstantXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Product(__.Constant<object>(null))}}, 
                 {"g_V_fold_productXVX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Product(__.V())}}, 
                 {"g_V_valuesXnameX_fold_productX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Product(2)}}, 
-                {"g_V_valuesXnameX_fold_productX7varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Product(p["xx1"])}}, 
--               {"g_V_valuesXnameX_fold_productXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Product(null)}}, 
++               {"g_V_valuesXnameX_fold_productX7varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Product(p["xx1"])}},
++               {"g_V_valuesXnameX_fold_productXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Product(null)}},
                 {"g_V_valuesXnonexistantX_fold_productXV_valuesXnameX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("nonexistant").Fold().Product(__.V().Values<object>("name").Fold())}}, 
                 {"g_V_valuesXnameX_fold_productXV_valuesXnonexistantX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Product(__.V().Values<object>("nonexistant").Fold())}}, 
                 {"g_V_valuesXageX_order_byXdescX_limitX3X_fold_productXV_valuesXageX_order_byXascX_limitX2X_foldX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Order().By(Order.Desc).Limit<object>(3).Fold().Product(__.V().Values<object>("age").Order().By(Order.Asc).Limit<object>(2).Fold()).Unfold<object>()}}, 
@@@ -1298,8 -1312,8 +1327,8 @@@
                 {"g_injectX__feature___test__nullX_rTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("feature  ", "one test ", null, "", " ", " abc", "abc ", " abc ", "  ").RTrim()}}, 
                 {"g_injectX__feature___test__nullX_rTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "  feature  ", " one test ", null, "", " ", " abc", "abc ", " abc ", "  " }).RTrim<object>(Scope.Local)}}, 
                 {"g_injectX__feature__X_rTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("  feature  ").RTrim()}}, 
-                {"g_injectXListXa_bXX_rTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).RTrim()}}, 
-                {"g_injectXListX1_2XX_rTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).RTrim<object>(Scope.Local)}}, 
 -               {"g_injectXListXa_bXX_rTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", "b" }).RTrim()}}, 
 -               {"g_injectXListX1_2XX_rTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2 }).RTrim<object>(Scope.Local)}}, 
++               {"g_injectXListXa_bXX_rTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).RTrim()}},
++               {"g_injectXListX1_2XX_rTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).RTrim<object>(Scope.Local)}},
                 {"g_V_valuesXnameX_rTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   ripple   ").Propert [...]
                 {"g_V_valuesXnameX_order_fold_rTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   r [...]
                 {"g_injectXthat_this_test_nullX_replaceXh_jX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("that", "this", "test", null).Replace("h", "j")}}, 
@@@ -1317,7 -1331,7 +1346,7 @@@
                 {"g_V_valuesXnameX_fold_orderXlocalX_by_reverse", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Order(Scope.Local).By().Reverse()}}, 
                 {"g_injectXnullX_reverse", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).Reverse()}}, 
                 {"g_injectXbX_reverse", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("b").Reverse()}}, 
-                {"g_injectX3_threeX_reverse", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Reverse()}}, 
 -               {"g_injectX3_threeX_reverse", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 3, "three" }).Reverse()}}, 
++               {"g_injectX3_threeX_reverse", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Reverse()}},
                 {"g_VX1X_asXaX_outXknowsX_asXbX_selectXa_bX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).As("a").Out("knows").As("b").Select<object>("a", "b")}}, 
                 {"g_VX1X_asXaX_outXknowsX_asXbX_selectXa_bX_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).As("a").Out("knows").As("b").Select<object>("a", "b").By("name")}}, 
                 {"g_VX1X_asXaX_outXknowsX_asXbX_selectXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).As("a").Out("knows").As("b").Select<object>("a")}}, 
@@@ -1385,7 -1399,7 +1414,7 @@@
                 {"g_withStrategiesXProductiveByStrategyX_V_asXaX_selectXaX_byXageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new ProductiveByStrategy()).V().As("a").Select<object>("a").By("age")}}, 
                 {"g_withSideEffectXk_nullX_injectXxX_selectXkX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSideEffect("k", null).Inject<object>("x").Select<object>("k")}}, 
                 {"g_V_out_in_selectXall_a_a_aX_byXunfold_name_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("A").Property("name", "a1").As("a1").AddV("B").Property("name", "b1").As("b1").AddE("ab").From("a1").To("b1"), (g,p) =>g.V().As("a").Out().As("a").In().As("a").Select<object>(Pop.All, "a", "a", "a").By(__.Unfold<object>().Values<object>("name").Fold())}}, 
-                {"g_withoutStrategiesXLazyBarrierStrategyX_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(LazyBarrierStrategy)).V().As("label").Aggregate(Scope.Local, "x").Select<object>("x").Select<object>("label")}}, 
 -               {"g_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("label").Aggregate(Scope.Local, "x").Barrier().Select<object>("x").Select<object>("label")}}, 
++               {"g_withoutStrategiesXLazyBarrierStrategyX_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(LazyBarrierStrategy)).V().As("label").Aggregate(Scope.Local, "x").Select<object>("x").Select<object>("label")}},
                 {"g_V_name_asXaX_selectXfirst_aX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").As("a").Select<object>(Pop.First, "a")}}, 
                 {"g_V_name_asXaX_selectXlast_aX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").As("a").Select<object>(Pop.Last, "a")}}, 
                 {"g_V_name_asXaX_selectXmixed_aX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").As("a").Select<object>(Pop.Mixed, "a")}}, 
@@@ -1415,12 -1429,12 +1444,12 @@@
                 {"g_injectXthat_this_testX_spiltXhX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("that", "this", "test", null).Split("h")}}, 
                 {"g_injectXhello_worldX_spiltXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("hello world").Split(null)}}, 
                 {"g_injectXthat_this_test_nullX_splitXemptyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("that", "this", "test", null).Split("")}}, 
-                {"g_injectXListXa_bXcX_splitXa_bX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Split("a")}}, 
 -               {"g_injectXListXa_bXcX_splitXa_bX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", "b" }).Split("a")}}, 
++               {"g_injectXListXa_bXcX_splitXa_bX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Split("a")}},
                 {"g_V_hasLabelXpersonX_valueXnameX_splitXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Values<object>("name").Split(null)}}, 
                 {"g_V_hasLabelXpersonX_valueXnameX_order_fold_splitXlocal_aX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Values<object>("name").Order().Fold().Split<object>(Scope.Local, "a").Unfold<object>()}}, 
                 {"g_V_hasLabelXpersonX_valueXnameX_order_fold_splitXlocal_emptyX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Values<object>("name").Order().Fold().Split<object>(Scope.Local, "").Unfold<object>()}}, 
                 {"g_injectXthat_this_testX_substringX1_8X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("test", "hello world", null).Substring(1, 8)}}, 
-                {"g_injectXListXa_bXcX_substringX1_2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Substring(1, 2)}}, 
 -               {"g_injectXListXa_bXcX_substringX1_2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "aa", "bb" }).Substring(1, 2)}}, 
++               {"g_injectXListXa_bXcX_substringX1_2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Substring(1, 2)}},
                 {"g_V_hasLabelXpersonX_valueXnameX_substringX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("software").Values<object>("name").Substring(2)}}, 
                 {"g_V_hasLabelXsoftwareX_valueXnameX_substringX1_4X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("software").Values<object>("name").Substring(1, 4)}}, 
                 {"g_V_hasLabelXpersonX_valueXnameX_order_fold_substringXlocal_2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("software").Values<object>("name").Order().Fold().Substring<object>(Scope.Local, 2)}}, 
@@@ -1464,8 -1478,8 +1493,8 @@@
                 {"g_injectX1b_26b_3iX_fold_sumXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>((byte) 1, (byte) 2, 3).Fold().Sum<object>(Scope.Local)}}, 
                 {"g_injectX1f_26f_3fX_fold_sumXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1f, 2f, 3f).Fold().Sum<object>(Scope.Local)}}, 
                 {"g_injectXfeature_test_nullX_toLower", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("FEATURE", "tESt", null).ToLower()}}, 
-                {"g_injectXfeature_test_nullX_toLowerXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).ToLower<object>(Scope.Local)}}, 
-                {"g_injectXListXa_bXX_toLower", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).ToLower()}}, 
 -               {"g_injectXfeature_test_nullX_toLowerXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "FEATURE", "tESt", null }).ToLower<object>(Scope.Local)}}, 
 -               {"g_injectXListXa_bXX_toLower", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", "b" }).ToLower()}}, 
++               {"g_injectXfeature_test_nullX_toLowerXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).ToLower<object>(Scope.Local)}},
++               {"g_injectXListXa_bXX_toLower", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).ToLower()}},
                 {"g_V_valuesXnameX_toLower", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "MARKO").Property("age", 29).As("marko").AddV("person").Property("name", "VADAS").Property("age", 27).As("vadas").AddV("software").Property("name", "LOP").Property("lang", "java").As("lop").AddV("person").Property("name", "JOSH").Property("age", 32).As("josh").AddV("software").Property("name", "RIPPLE").Property("lang", "jav [...]
                 {"g_V_valuesXnameX_toLowerXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "MARKO").Property("age", 29).As("marko").AddV("person").Property("name", "VADAS").Property("age", 27).As("vadas").AddV("software").Property("name", "LOP").Property("lang", "java").As("lop").AddV("person").Property("name", "JOSH").Property("age", 32).As("josh").AddV("software").Property("name", "RIPPLE").Property("lang [...]
                 {"g_V_valuesXnameX_order_fold_toLowerXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "MARKO").Property("age", 29).As("marko").AddV("person").Property("name", "VADAS").Property("age", 27).As("vadas").AddV("software").Property("name", "LOP").Property("lang", "java").As("lop").AddV("person").Property("name", "JOSH").Property("age", 32).As("josh").AddV("software").Property("name", "RIPPLE").Pro [...]
@@@ -1512,14 -1526,14 +1541,14 @@@
                 {"g_VX1X_outE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE()}}, 
                 {"g_VX2X_outE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid2"]).InE()}}, 
                 {"g_VX4X_bothEXcreatedX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid4"]).BothE("created")}}, 
-                {"g_VX4X_bothEXcreatedvarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid4"]).BothE(p["xx1"])}}, 
 -               {"g_VX4X_bothEXcreatedvarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid4"]).BothE((string) p["xx1"])}}, 
++               {"g_VX4X_bothEXcreatedvarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid4"]).BothE(p["xx1"])}},
                 {"g_VX4X_bothE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid4"]).BothE()}}, 
                 {"g_V_out_outE_inV_inE_inV_both_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().OutE().InV().InE().InV().Both().Values<object>("name")}}, 
                 {"g_VX2X_inE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid2"]).BothE()}}, 
                 {"g_VX1X_outXknowsX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out("knows")}}, 
                 {"g_VX1AsStringX_outXknowsX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out("knows")}}, 
                 {"g_VX1X_outXknows_createdX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out("knows", "created")}}, 
-                {"g_VX1X_outXknowsvar_createdvarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out(p["xx2"], p["xx3"])}}, 
 -               {"g_VX1X_outXknowsvar_createdvarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out((string) p["xx2"], (string) p["xx3"])}}, 
++               {"g_VX1X_outXknowsvar_createdvarX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out(p["xx2"], p["xx3"])}},
                 {"g_V_out_out", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out()}}, 
                 {"g_VX1X_out_out_out", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Out().Out()}}, 
                 {"g_VX1X_out_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Values<object>("name")}}, 
@@@ -1611,14 -1625,10 +1640,14 @@@
                 {"InjectX1dX_notXerrorX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1d).Not(__.Is(P.Gt(Double.NaN)))}}, 
                 {"InjectX1dX_notXisXeqXNaNXXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1d).Not(__.Is(P.Eq(Double.NaN)))}}, 
                 {"InjectXInfX_eqXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Eq(Double.PositiveInfinity))}}, 
-                {"InjectXInfArgX_eqXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Eq(Double.PositiveInfinity))}}, 
--               {"InjectXInfX_neqXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Neq(Double.PositiveInfinity))}}, 
-                {"InjectXInfArgX_neqXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Neq(Double.PositiveInfinity))}}, 
--               {"InjectXNegInfX_eqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Eq(Double.NegativeInfinity))}}, 
-                {"InjectXNegInfArgX_eqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Eq(Double.NegativeInfinity))}}, 
--               {"InjectXNegInfX_neqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Neq(Double.NegativeInfinity))}}, 
-                {"InjectXNegInfArgX_neqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Neq(Double.NegativeInfinity))}}, 
--               {"InjectXInfX_gtXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Gt(Double.NegativeInfinity))}}, 
++               {"InjectXInfArgX_eqXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Eq(Double.PositiveInfinity))}},
++               {"InjectXInfX_neqXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Neq(Double.PositiveInfinity))}},
++               {"InjectXInfArgX_neqXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Neq(Double.PositiveInfinity))}},
++               {"InjectXNegInfX_eqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Eq(Double.NegativeInfinity))}},
++               {"InjectXNegInfArgX_eqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Eq(Double.NegativeInfinity))}},
++               {"InjectXNegInfX_neqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Neq(Double.NegativeInfinity))}},
++               {"InjectXNegInfArgX_neqXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Neq(Double.NegativeInfinity))}},
++               {"InjectXInfX_gtXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Gt(Double.NegativeInfinity))}},
                 {"InjectXInfX_ltXNegInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.PositiveInfinity).Is(P.Lt(Double.NegativeInfinity))}}, 
                 {"InjectXNegInfX_ltXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Lt(Double.PositiveInfinity))}}, 
                 {"InjectXNegInfX_gtXInfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Double.NegativeInfinity).Is(P.Gt(Double.PositiveInfinity))}}, 
@@@ -1633,18 -1643,11 +1662,18 @@@
                 {"g_V_values_order", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>().Order()}}, 
                 {"g_V_properties_order", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Properties<object>().Order()}}, 
                 {"g_V_properties_order_id", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Properties<object>().Order().Id()}}, 
 -               {"g_E_properties_order_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5d).Property("a", 10).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 11).AddE("self").From("a").To("a").Property("weight", 0.4d).Property("a", 12).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 13).AddE("self" [...]
 +<<<<<<< HEAD
-                {"g_E_properties_order_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().Properties<object>().Order().Value<object>()}}, 
-                {"g_E_properties_order_byXdescX_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().Properties<object>().Order().By(Order.Desc).Value<object>()}}, 
-                {"g_inject_order", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order()}}, 
-                {"g_inject_order_byXdescX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order().By(Order.Desc)}}, 
++               {"g_E_properties_order_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().Properties<object>().Order().Value<object>()}},
++               {"g_E_properties_order_byXdescX_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().Properties<object>().Order().By(Order.Desc).Value<object>()}},
++               {"g_inject_order", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order()}},
++               {"g_inject_order_byXdescX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order().By(Order.Desc)}},
 +=======
-                {"g_E_properties_order_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5d).Property("a", 10).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 11).AddE("self").From("a").To("a").Property("weight", 0.4d).Property("a", 12).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 13).AddE("self" [...]
++               {"g_E_properties_order_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5d).Property("a", 10).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 11).AddE("self").From("a").To("a").Property("weight", 0.4d).Property("a", 12).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 13).AddE("self" [...]
                 {"g_E_properties_order_byXdescX_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5d).Property("a", 10).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 11).AddE("self").From("a").To("a").Property("weight", 0.4d).Property("a", 12).AddE("self").From("a").To("a").Property("weight", 1.0d).Property("a", 13).Ad [...]
                 {"g_inject_order", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("zzz", "foo", new List<object> { "a", "b", "c", "d" }, 1, new List<object> { "a", "b", "c" }, new Dictionary<object, object> {{ "a", "a" }, { "b", "b" }}, null, 2.0d, new Dictionary<object, object> {{ "a", "a" }, { "b", false }, { "c", "c" }}, "bar", true, false, Double.PositiveInfinity, Double.NaN, Double.NegativeInfinity).Order()}}, 
                 {"g_inject_order_byXdescX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("zzz", "foo", new List<object> { "a", "b", "c", "d" }, 1, new List<object> { "a", "b", "c" }, new Dictionary<object, object> {{ "a", "a" }, { "b", "b" }}, null, 2.0d, new Dictionary<object, object> {{ "a", "a" }, { "b", false }, { "c", "c" }}, "bar", true, false, Double.PositiveInfinity, Double.NaN, Double.NegativeInfinity).Order().By(Order.D [...]
 -               {"g_V_out_out_order_byXascX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Order().By(Order.Asc)}}, 
 +>>>>>>> 3.8-dev
-                {"g_V_out_out_order_byXascX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Order().By(Order.Asc)}}, 
++               {"g_V_out_out_order_byXascX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Order().By(Order.Asc)}},
                 {"g_V_out_out_order_byXdescX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Order().By(Order.Desc)}}, 
                 {"g_V_out_out_asXheadX_path_order_byXascX_selectXheadX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().As("head").Path().Order().By(Order.Asc).Select<object>("head")}}, 
                 {"g_V_out_out_asXheadX_path_order_byXdescX_selectXheadX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().As("head").Path().Order().By(Order.Desc).Select<object>("head")}}, 
@@@ -1756,15 -1759,10 +1785,15 @@@
                 {"g_VX1X_valuesXageX_inject", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["xx1"]).Values<object>("age").Inject()}}, 
                 {"g_injectXnull_1_3_nullX_asXaX_selectXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null, 1, 3, null).As("a").Select<object>("a")}}, 
                 {"g_injectX1_3X_injectX100_300X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1, 3).Inject(100, 300)}}, 
-                {"g_injectX1var_3varX_injectX100var_300varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).Inject(p["xx3"], p["xx4"])}}, 
--               {"g_injectX1_3_100_300X_list", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 3, 100, 300 })}}, 
-                {"g_injectX1_3_100_300X_listvar", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}}, 
--               {"g_injectX1_3_100_300X_set", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new HashSet<object> { 1, 3, 100, 300 })}}, 
-                {"g_injectX1_3_100_300X_setvar", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}}, 
--               {"g_injectX1_1X_set", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new HashSet<object> { 1, 1 })}}, 
-                {"g_injectX1_1X_setvar", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}}, 
-                {"g_injectX_set", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}}, 
--               {"g_io_readXkryoX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Io<object>("data/tinkerpop-modern.kryo").Read(), (g,p) =>g.V(), (g,p) =>g.E()}}, 
++               {"g_injectX1var_3varX_injectX100var_300varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).Inject(p["xx3"], p["xx4"])}},
++               {"g_injectX1_3_100_300X_list", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 3, 100, 300 })}},
++               {"g_injectX1_3_100_300X_listvar", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}},
++               {"g_injectX1_3_100_300X_set", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new HashSet<object> { 1, 3, 100, 300 })}},
++               {"g_injectX1_3_100_300X_setvar", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}},
++               {"g_injectX1_1X_set", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new HashSet<object> { 1, 1 })}},
++               {"g_injectX1_1X_setvar", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}},
++               {"g_injectX_set", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"])}},
++               {"g_io_readXkryoX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Io<object>("data/tinkerpop-modern.kryo").Read(), (g,p) =>g.V(), (g,p) =>g.E()}},
                 {"g_io_read_withXreader_gryoX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Io<object>("data/tinkerpop-modern.kryo").With(IO.Reader, IO.Gryo).Read(), (g,p) =>g.V(), (g,p) =>g.E()}}, 
                 {"g_io_readXgraphsonX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Io<object>("data/tinkerpop-modern.json").Read(), (g,p) =>g.V(), (g,p) =>g.E()}}, 
                 {"g_io_read_withXreader_graphsonX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Io<object>("data/tinkerpop-modern.json").With(IO.Reader, IO.GraphSON).Read(), (g,p) =>g.V(), (g,p) =>g.E()}}, 
diff --cc gremlin-go/driver/cucumber/gremlin.go
index 55a8ed54fd,9ad0b1fd5f..06639740af
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@@ -146,13 -146,13 +146,13 @@@ var translationMap = map[string][]func(
      "g_V_valuesXageX_order_byXdescX_fold_allXgtX10XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Fold().All(gremlingo.P.Gt(10))}}, 
      "g_V_valuesXageX_order_byXdescX_fold_allXgtX30XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Fold().All(gremlingo.P.Gt(30))}}, 
      "g_injectXabc_bcdX_allXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"abc", "bcd"}).All(gremlingo.P.Eq("bcd"))}}, 
-     "g_injectXbcd_bcdX_allXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.P.Eq("bcd"))}}, 
-     "g_injectXnull_abcX_allXTextP_startingWithXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.TextP.StartingWith("a"))}}, 
-     "g_injectX5_8_10_10_7X_allXgteX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).All(gremlingo.P.Gte(7))}}, 
 -    "g_injectXbcd_bcdX_allXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"bcd", "bcd"}).All(gremlingo.P.Eq("bcd"))}}, 
 -    "g_injectXnull_abcX_allXTextP_startingWithXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{nil, "abc"}).All(gremlingo.TextP.StartingWith("a"))}}, 
 -    "g_injectX5_8_10_10_7X_allXgteX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{5, 8, 10}, []interface{}{10, 7}).All(gremlingo.P.Gte(7))}}, 
++    "g_injectXbcd_bcdX_allXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.P.Eq("bcd"))}},
++    "g_injectXnull_abcX_allXTextP_startingWithXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.TextP.StartingWith("a"))}},
++    "g_injectX5_8_10_10_7X_allXgteX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).All(gremlingo.P.Gte(7))}},
      "g_injectXnullX_allXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).All(gremlingo.P.Eq(nil))}}, 
      "g_injectX7X_allXeqX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(7).All(gremlingo.P.Eq(7))}}, 
-     "g_injectXnull_nullX_allXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.P.Eq(nil))}}, 
-     "g_injectX3_threeX_allXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.P.Eq(3))}}, 
 -    "g_injectXnull_nullX_allXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{nil, nil}).All(gremlingo.P.Eq(nil))}}, 
 -    "g_injectX3_threeX_allXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{3, "three"}).All(gremlingo.P.Eq(3))}}, 
++    "g_injectXnull_nullX_allXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.P.Eq(nil))}},
++    "g_injectX3_threeX_allXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).All(gremlingo.P.Eq(3))}},
      "g_V_andXhasXage_gt_27X__outE_count_gte_2X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().And(gremlingo.T__.Has("age", gremlingo.P.Gt(27)), gremlingo.T__.OutE().Count().Is(gremlingo.P.Gte(2))).Values("name")}}, 
      "g_V_andXoutE__hasXlabel_personX_and_hasXage_gte_32XX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().And(gremlingo.T__.OutE(), gremlingo.T__.Has(gremlingo.T.Label, "person").And().Has("age", gremlingo.P.Gte(32))).Values("name")}}, 
      "g_V_asXaX_outXknowsX_and_outXcreatedX_inXcreatedX_asXaX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out("knows").And().Out("created").In("created").As("a").Values("name")}}, 
@@@ -163,16 -163,15 +163,16 @@@
      "g_V_valuesXageX_order_byXdescX_fold_anyXgtX10XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Fold().Any(gremlingo.P.Gt(10))}}, 
      "g_V_valuesXageX_order_byXdescX_fold_anyXgtX42XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Fold().Any(gremlingo.P.Gt(42))}}, 
      "g_injectXabc_cdeX_anyXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"abc", "cde"}).Any(gremlingo.P.Eq("bcd"))}}, 
-     "g_injectXabc_bcdX_anyXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq("bcd"))}}, 
-     "g_injectXnull_abcX_anyXTextP_startingWithXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.TextP.StartingWith("a"))}}, 
-     "g_injectX5_8_10_10_7X_anyXeqX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).Any(gremlingo.P.Eq(7))}}, 
 -    "g_injectXabc_bcdX_anyXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"abc", "bcd"}).Any(gremlingo.P.Eq("bcd"))}}, 
 -    "g_injectXnull_abcX_anyXTextP_startingWithXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{nil, "abc"}).Any(gremlingo.TextP.StartingWith("a"))}}, 
 -    "g_injectX5_8_10_10_7X_anyXeqX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{5, 8, 10}, []interface{}{10, 7}).Any(gremlingo.P.Eq(7))}}, 
++    "g_injectXabc_bcdX_anyXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq("bcd"))}},
++    "g_injectXnull_abcX_anyXTextP_startingWithXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.TextP.StartingWith("a"))}},
++    "g_injectX5_8_10_10_7X_anyXeqX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).Any(gremlingo.P.Eq(7))}},
      "g_injectXnullX_anyXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).Any(gremlingo.P.Eq(nil))}}, 
      "g_injectX7X_anyXeqX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(7).Any(gremlingo.P.Eq(7))}}, 
-     "g_injectXnull_nullX_anyXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq(nil))}}, 
-     "g_injectX3_threeX_anyXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq(3))}}, 
 -    "g_injectXnull_nullX_anyXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{nil, nil}).Any(gremlingo.P.Eq(nil))}}, 
 -    "g_injectX3_threeX_anyXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{3, "three"}).Any(gremlingo.P.Eq(3))}}, 
++    "g_injectXnull_nullX_anyXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq(nil))}},
++    "g_injectX3_threeX_anyXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq(3))}},
      "g_V_coinX1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(1.0)}}, 
-     "g_V_coinX1varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(p["xx1"])}}, 
--    "g_V_coinX0X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(0.0)}}, 
++    "g_V_coinX1varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(p["xx1"])}},
++    "g_V_coinX0X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(0.0)}},
      "g_withStrategiesXSeedStrategyX_V_order_byXnameX_coinX50X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.SeedStrategy(gremlingo.SeedStrategyConfig{Seed: 999999})).V().Order().By("name").Coin(0.5)}}, 
      "g_VX1X_outXcreatedX_inXcreatedX_cyclicPath": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("created").In("created").CyclicPath()}}, 
      "g_VX1X_both_both_cyclicPath_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Both().Both().CyclicPath().By("age")}}, 
@@@ -292,8 -291,7 +292,8 @@@
      "g_V_hasIdXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(gremlingo.P.Eq(nil))}}, 
      "g_V_hasIdX2_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid2"], nil)}}, 
      "g_V_hasIdXmarkovar_vadasvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"], p["vid2"])}}, 
-     "g_V_hasIdXmarkovar_vadasvar_petervarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"], p["vid2"])}}, 
--    "g_V_hasIdX2AsString_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid2"], nil)}}, 
++    "g_V_hasIdXmarkovar_vadasvar_petervarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"], p["vid2"])}},
++    "g_V_hasIdX2AsString_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid2"], nil)}},
      "g_V_hasIdX1AsString_2AsString_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"], p["vid2"], nil)}}, 
      "g_V_hasIdXnull_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(nil, p["vid2"])}}, 
      "g_V_hasIdX1X_hasIdX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"]).HasId(p["vid2"])}}, 
@@@ -348,14 -346,14 +348,14 @@@
      "g_V_valuesXageX_order_byXdescX_fold_noneXltX10XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Fold().None(gremlingo.P.Lt(10))}}, 
      "g_V_valuesXageX_order_byXdescX_fold_noneXgtX30XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Fold().None(gremlingo.P.Gt(30))}}, 
      "g_injectXabc_bcdX_noneXeqXbcdXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"abc", "bcd"}).None(gremlingo.P.Eq("bcd"))}}, 
-     "g_injectXbcd_bcdX_noneXeqXabcXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Eq("abc"))}}, 
-     "g_injectXnull_bcdX_noneXP_eqXabcXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Eq("abc"))}}, 
-     "g_injectX5_8_10_10_7X_noneXltX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).None(gremlingo.P.Lt(7))}}, 
 -    "g_injectXbcd_bcdX_noneXeqXabcXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"bcd", "bcd"}).None(gremlingo.P.Eq("abc"))}}, 
 -    "g_injectXnull_bcdX_noneXP_eqXabcXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{nil, "bcd"}).None(gremlingo.P.Eq("abc"))}}, 
 -    "g_injectX5_8_10_10_7X_noneXltX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{5, 8, 10}, []interface{}{10, 7}).None(gremlingo.P.Lt(7))}}, 
++    "g_injectXbcd_bcdX_noneXeqXabcXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Eq("abc"))}},
++    "g_injectXnull_bcdX_noneXP_eqXabcXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Eq("abc"))}},
++    "g_injectX5_8_10_10_7X_noneXltX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).None(gremlingo.P.Lt(7))}},
      "g_injectXnullX_noneXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).None(gremlingo.P.Eq(nil))}}, 
      "g_injectX7X_noneXeqX7XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(7).None(gremlingo.P.Eq(7))}}, 
-     "g_injectXnull_1_emptyX_noneXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).None(gremlingo.P.Eq(nil))}}, 
-     "g_injectXnull_nullX_noneXnotXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Neq(nil))}}, 
-     "g_injectX3_threeX_noneXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Eq(3))}}, 
 -    "g_injectXnull_1_emptyX_noneXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{nil, 1}, []interface{}{}).None(gremlingo.P.Eq(nil))}}, 
 -    "g_injectXnull_nullX_noneXnotXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{nil, nil}).None(gremlingo.P.Neq(nil))}}, 
 -    "g_injectX3_threeX_noneXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{int32(3), "three"}).None(gremlingo.P.Eq(3))}}, 
++    "g_injectXnull_1_emptyX_noneXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).None(gremlingo.P.Eq(nil))}},
++    "g_injectXnull_nullX_noneXnotXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Neq(nil))}},
++    "g_injectX3_threeX_noneXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).None(gremlingo.P.Eq(3))}},
      "g_V_orXhasXage_gt_27X__outE_count_gte_2X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Or(gremlingo.T__.Has("age", gremlingo.P.Gt(27)), gremlingo.T__.OutE().Count().Is(gremlingo.P.Gte(2))).Values("name")}}, 
      "g_V_orXoutEXknowsX__hasXlabel_softwareX_or_hasXage_gte_35XX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Or(gremlingo.T__.OutE("knows"), gremlingo.T__.Has(gremlingo.T.Label, "software").Or().Has("age", gremlingo.P.Gte(35))).Values("name")}}, 
      "g_V_asXaX_orXselectXaX_selectXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Or(gremlingo.T__.Select("a"), gremlingo.T__.Select("a"))}}, 
@@@ -684,23 -682,47 +684,52 @@@
      "g_injectXmixed_trueX_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("tRUe").AsBool()}}, 
      "g_injectXnullX_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).AsBool()}}, 
      "g_injectXhelloX_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("hello").AsBool()}}, 
-     "g_injectX1_2X_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsBool()}}, 
 -    "g_injectX1_2X_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2}).AsBool()}}, 
++    "g_injectX1_2X_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsBool()}},
      "g_VXX_localX_outE_countX_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Local(gremlingo.T__.OutE().Count()).AsBool()}}, 
      "g_V_sackXassignX_byX_hasLabelXpersonX_count_asBoolX_sackXandX_byX_outE_count_asBoolX_sack_path": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Sack(gremlingo.Operator.Assign).By(gremlingo.T__.HasLabel("person").Count().AsBool()).Sack(gremlingo.Operator.And).By(gremlingo.T__.OutE().Count().AsBool()).Sack().Path()}}, 
      "g_injectXstrX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("2023-08-02T00:00:00Z").AsDate()}}, 
      "g_injectXstr_offsetX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("2023-08-02T00:00:00-07:00").AsDate()}}, 
      "g_injectX1694017707000X_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1694017707000).AsDate()}}, 
-     "g_injectX1694017708000LX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsDate()}}, 
-     "g_injectX1694017709000dX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsDate()}}, 
-     "g_injectX1_2X_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsDate()}}, 
 -    "g_injectX1694017708000LX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int64(1694017708000)).AsDate()}}, 
 -    "g_injectX1694017709000dX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1694017709000.1).AsDate()}}, 
 -    "g_injectX1_2X_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2}).AsDate()}}, 
++    "g_injectX1694017708000LX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsDate()}},
++    "g_injectX1694017709000dX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsDate()}},
++    "g_injectX1_2X_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsDate()}},
      "g_injectXnullX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).AsDate()}}, 
      "g_injectXinvalidstrX_asDate": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("This String is not an ISO 8601 Date").AsDate()}}, 
-     "g_injectX1_2X_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).AsString()}}, 
-     "g_injectX1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).AsString(gremlingo.Scope.Local)}}, 
-     "g_injectXlist_1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsString(gremlingo.Scope.Local)}}, 
-     "g_injectX1_nullX_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, p["xx1"]).AsString()}}, 
-     "g_injectX1_nullX_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsString(gremlingo.Scope.Local)}}, 
 -    "g_injectX5bX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int8(5)).AsNumber()}}, 
 -    "g_injectX5sX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int16(5)).AsNumber()}}, 
 -    "g_injectX5iX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int32(5)).AsNumber()}}, 
 -    "g_injectX5lX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int64(5)).AsNumber()}}, 
 -    "g_injectX5nX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.ParseBigInt("5")).AsNumber()}}, 
 -    "g_injectX5_0X_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5.0).AsNumber()}}, 
 -    "g_injectX5_75fX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(float32(5.75)).AsNumber()}}, 
 -    "g_injectX5_43X_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5.43).AsNumber(gremlingo.N.Int)}}, 
 -    "g_injectX5_67X_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5.67).AsNumber(gremlingo.N.Int)}}, 
 -    "g_injectX5X_asNumberXN_longX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5).AsNumber(gremlingo.N.Long)}}, 
 -    "g_injectX12X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(12).AsNumber(gremlingo.N.Byte)}}, 
 -    "g_injectX32768X_asNumberXN_shortX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(32768).AsNumber(gremlingo.N.Short)}}, 
 -    "g_injectX300X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(300).AsNumber(gremlingo.N.Byte)}}, 
 -    "g_injectX5X_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("5").AsNumber()}}, 
 -    "g_injectX5X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("5").AsNumber(gremlingo.N.Byte)}}, 
 -    "g_injectX1_000X_asNumberXN_bigIntX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("1,000").AsNumber(gremlingo.N.BigInt)}}, 
 -    "g_injectXtestX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("test").AsNumber()}}, 
 -    "g_injectX_1_2_3_4X_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2, 3, 4}).AsNumber()}}, 
 -    "g_injectX1_2_3_4X_unfold_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2, 3, 4}).Unfold().AsNumber()}}, 
 -    "g_injectX_1__2__3__4_X_asNumberXX_foldXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("1", 2, "3", 4).AsNumber().Fold()}}, 
 -    "g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1.0, 2, 3, "4", "0x5").AsNumber().Sum().AsNumber(gremlingo.N.Byte)}}, 
 -    "g_injectXnullX_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).AsNumber(gremlingo.N.Int)}}, 
 -    "g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out("knows").As("b").Math("a + b").By("age").AsNumber(gremlingo.N.Int)}}, 
 -    "g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("x", 100).V().Values("age").Math("_ + x").AsNumber(gremlingo.N.Long)}}, 
 -    "g_injectX1_2X_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1, 2).AsString()}}, 
 -    "g_injectX1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1, 2).AsString(gremlingo.Scope.Local)}}, 
 -    "g_injectXlist_1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2}).AsString(gremlingo.Scope.Local)}}, 
 -    "g_injectX1_nullX_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, 1).AsString()}}, 
 -    "g_injectX1_nullX_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, nil}).AsString(gremlingo.Scope.Local)}}, 
--    "g_V_valueMapXnameX_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("name").AsString()}}, 
++    "g_injectX1_2X_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).AsString()}},
++    "g_injectX1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).AsString(gremlingo.Scope.Local)}},
++    "g_injectXlist_1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsString(gremlingo.Scope.Local)}},
++    "g_injectX1_nullX_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, p["xx1"]).AsString()}},
++    "g_injectX1_nullX_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).AsString(gremlingo.Scope.Local)}},
++    "g_injectX5bX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int8(5)).AsNumber()}},
++    "g_injectX5sX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int16(5)).AsNumber()}},
++    "g_injectX5iX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int32(5)).AsNumber()}},
++    "g_injectX5lX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int64(5)).AsNumber()}},
++    "g_injectX5nX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.ParseBigInt("5")).AsNumber()}},
++    "g_injectX5_0X_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5.0).AsNumber()}},
++    "g_injectX5_75fX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(float32(5.75)).AsNumber()}},
++    "g_injectX5_43X_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5.43).AsNumber(gremlingo.N.Int)}},
++    "g_injectX5_67X_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5.67).AsNumber(gremlingo.N.Int)}},
++    "g_injectX5X_asNumberXN_longX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(5).AsNumber(gremlingo.N.Long)}},
++    "g_injectX12X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(12).AsNumber(gremlingo.N.Byte)}},
++    "g_injectX32768X_asNumberXN_shortX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(32768).AsNumber(gremlingo.N.Short)}},
++    "g_injectX300X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(300).AsNumber(gremlingo.N.Byte)}},
++    "g_injectX5X_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("5").AsNumber()}},
++    "g_injectX5X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("5").AsNumber(gremlingo.N.Byte)}},
++    "g_injectX1_000X_asNumberXN_bigIntX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("1,000").AsNumber(gremlingo.N.BigInt)}},
++    "g_injectXtestX_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("test").AsNumber()}},
++    "g_injectX_1_2_3_4X_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2, 3, 4}).AsNumber()}},
++    "g_injectX1_2_3_4X_unfold_asNumber": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2, 3, 4}).Unfold().AsNumber()}},
++    "g_injectX_1__2__3__4_X_asNumberXX_foldXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("1", 2, "3", 4).AsNumber().Fold()}},
++    "g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1.0, 2, 3, "4", "0x5").AsNumber().Sum().AsNumber(gremlingo.N.Byte)}},
++    "g_injectXnullX_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).AsNumber(gremlingo.N.Int)}},
++    "g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out("knows").As("b").Math("a + b").By("age").AsNumber(gremlingo.N.Int)}},
++    "g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("x", 100).V().Values("age").Math("_ + x").AsNumber(gremlingo.N.Long)}},
++    "g_injectX1_2X_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1, 2).AsString()}},
++    "g_injectX1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1, 2).AsString(gremlingo.Scope.Local)}},
++    "g_injectXlist_1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2}).AsString(gremlingo.Scope.Local)}},
++    "g_injectX1_nullX_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, 1).AsString()}},
++    "g_injectX1_nullX_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, nil}).AsString(gremlingo.Scope.Local)}},
++    "g_V_valueMapXnameX_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("name").AsString()}},
      "g_V_valueMapXnameX_order_fold_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("name").Order().Fold().AsString(gremlingo.Scope.Local)}}, 
      "g_V_asString": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().AsString()}}, 
      "g_V_fold_asStringXlocalX_orderXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().AsString(gremlingo.Scope.Local).Order(gremlingo.Scope.Local)}}, 
@@@ -740,20 -762,19 +769,20 @@@
      "g_V_fold_combineXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Combine(gremlingo.T__.Constant(nil))}}, 
      "g_V_fold_combineXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Combine(gremlingo.T__.V())}}, 
      "g_V_valuesXnameX_fold_combineX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(2)}}, 
-     "g_V_valuesXnameX_fold_combineX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(p["xx1"])}}, 
--    "g_V_valuesXnameX_fold_combineXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(nil)}}, 
++    "g_V_valuesXnameX_fold_combineX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(p["xx1"])}},
++    "g_V_valuesXnameX_fold_combineXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(nil)}},
      "g_V_valuesXnonexistantX_fold_combineXV_valuesXnameX_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Combine(gremlingo.T__.V().Values("name").Fold()).Unfold()}}, 
      "g_V_valuesXnameX_fold_combineXV_valuesXnonexistantX_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(gremlingo.T__.V().Values("nonexistant").Fold()).Unfold()}}, 
      "g_V_valuesXageX_order_byXdescX_fold_combineXV_valuesXageX_order_byXdescX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Fold().Combine(gremlingo.T__.V().Values("age").Order().By(gremlingo.Order.Desc).Fold())}}, 
-     "g_V_out_path_byXvaluesXnameX_toUpperX_combineXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Combine(p["xx1"])}}, 
-     "g_injectXxx1X_combineXV_valuesXnameX_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(gremlingo.T__.V().Values("name").Fold()).Unfold()}}, 
-     "g_V_valueMapXlocationX_selectXvaluesX_unfold_combineXseattle_vancouverX_orderXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Combine(p["xx1"]).Order(gremlingo.Scope.Local)}}, 
-     "g_V_out_out_path_byXnameX_combineXempty_listX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Combine(p["xx1"])}}, 
 -    "g_V_out_path_byXvaluesXnameX_toUpperX_combineXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Combine([]interface{}{"MARKO"})}}, 
 -    "g_injectXxx1X_combineXV_valuesXnameX_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"marko"}).Combine(gremlingo.T__.V().Values("name").Fold()).Unfold()}}, 
 -    "g_V_valueMapXlocationX_selectXvaluesX_unfold_combineXseattle_vancouverX_orderXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Combine([]interface{}{"seattle", "vancouver"}).Order(gremlingo.Scope.Local)}}, 
 -    "g_V_out_out_path_byXnameX_combineXempty_listX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Combine([]interface{}{})}}, 
++    "g_V_out_path_byXvaluesXnameX_toUpperX_combineXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Combine(p["xx1"])}},
++    "g_injectXxx1X_combineXV_valuesXnameX_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(gremlingo.T__.V().Values("name").Fold()).Unfold()}},
++    "g_V_valueMapXlocationX_selectXvaluesX_unfold_combineXseattle_vancouverX_orderXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Combine(p["xx1"]).Order(gremlingo.Scope.Local)}},
++    "g_V_out_out_path_byXnameX_combineXempty_listX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Combine(p["xx1"])}},
      "g_V_valuesXageX_order_fold_combineXconstantX27X_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().Fold().Combine(gremlingo.T__.Constant(27).Fold())}}, 
-     "g_V_out_out_path_byXnameX_combineXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Combine(p["xx1"])}}, 
-     "g_injectXa_null_bX_combineXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(p["xx2"])}}, 
-     "g_injectXa_null_bX_combineXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(p["xx2"])}}, 
-     "g_injectX3_threeX_combineXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(p["xx2"])}}, 
 -    "g_V_out_out_path_byXnameX_combineXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Combine([]interface{}{"dave", "kelvin"})}}, 
 -    "g_injectXa_null_bX_combineXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Combine([]interface{}{"a", "c"})}}, 
 -    "g_injectXa_null_bX_combineXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Combine([]interface{}{"a", nil, "c"})}}, 
 -    "g_injectX3_threeX_combineXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{3, "three"}).Combine([]interface{}{"five", "three", int32(7)})}}, 
++    "g_V_out_out_path_byXnameX_combineXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Combine(p["xx1"])}},
++    "g_injectXa_null_bX_combineXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(p["xx2"])}},
++    "g_injectXa_null_bX_combineXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(p["xx2"])}},
++    "g_injectX3_threeX_combineXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Combine(p["xx2"])}},
      "g_injectXa_bX_concat": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("a", "b").Concat()}}, 
      "g_injectXa_bX_concat_XcX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("a", "b").Concat("c")}}, 
      "g_injectXa_bX_concat_Xc_dX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("a", "b").Concat("c", "d")}}, 
@@@ -773,8 -794,7 +802,8 @@@
      "g_V_valuesXnameX_conjoinX1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Conjoin("1")}}, 
      "g_V_valuesXnonexistantX_fold_conjoinX_X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Conjoin(";")}}, 
      "g_V_valuesXnameX_order_fold_conjoinX_X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order().Fold().Conjoin("_")}}, 
-     "g_V_valuesXageX_order_fold_conjoinXsemicolonX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().Fold().Conjoin(";")}}, 
-     "g_V_valuesXageX_order_fold_conjoinXslashX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().Fold().Conjoin(p["xx1"])}}, 
 -    "g_V_valuesXageX_order_fold_conjoinX_X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().Fold().Conjoin(";")}}, 
++    "g_V_valuesXageX_order_fold_conjoinXsemicolonX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().Fold().Conjoin(";")}},
++    "g_V_valuesXageX_order_fold_conjoinXslashX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().Fold().Conjoin(p["xx1"])}},
      "g_V_out_path_byXvaluesXnameX_toUpperX_conjoinXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Conjoin("MARKO")}}, 
      "g_injectXmarkoX_conjoinX_X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"marko"}).Conjoin("-")}}, 
      "g_V_valueMapXlocationX_selectXvaluesX_unfold_orderXlocalX_conjoinX1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Order(gremlingo.Scope.Local).Conjoin("1")}}, 
@@@ -817,8 -837,7 +846,8 @@@
      "g_V_fold_differenceXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Difference(gremlingo.T__.Constant(nil))}}, 
      "g_V_fold_differenceXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Difference(gremlingo.T__.V())}}, 
      "g_V_valuesXnameX_fold_differenceX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(2)}}, 
-     "g_V_valuesXnameX_fold_differenceX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(p["xx1"])}}, 
--    "g_V_valuesXnameX_fold_differenceXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(nil)}}, 
++    "g_V_valuesXnameX_fold_differenceX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(p["xx1"])}},
++    "g_V_valuesXnameX_fold_differenceXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(nil)}},
      "g_V_valuesXnonexistantX_fold_differenceXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Difference(gremlingo.T__.V().Values("name").Fold())}}, 
      "g_V_valuesXnameX_fold_differenceXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(gremlingo.T__.V().Values("nonexistant").Fold())}}, 
      "g_V_valuesXageX_fold_differenceXV_valuesXageX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold().Difference(gremlingo.T__.V().Values("age").Fold())}}, 
@@@ -829,16 -848,15 +858,16 @@@
      "g_V_out_out_path_byXnameX_differenceXempty_listX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Difference([]interface{}{})}}, 
      "g_V_valuesXageX_fold_differenceXconstantX27X_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold().Difference(gremlingo.T__.Constant(27).Fold())}}, 
      "g_V_out_out_path_byXnameX_differenceXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Difference([]interface{}{"dave", "kelvin"})}}, 
-     "g_injectXa_null_bX_differenceXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Difference(p["xx2"])}}, 
-     "g_injectXa_null_bX_differenceXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Difference(p["xx2"])}}, 
-     "g_injectX3_threeX_differenceXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Difference(p["xx2"])}}, 
 -    "g_injectXa_null_bX_differenceXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Difference([]interface{}{"a", "c"})}}, 
 -    "g_injectXa_null_bX_differenceXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Difference([]interface{}{"a", nil, "c"})}}, 
 -    "g_injectX3_threeX_differenceXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{3, "three"}).Difference([]interface{}{"five", "three", int32(7)})}}, 
++    "g_injectXa_null_bX_differenceXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Difference(p["xx2"])}},
++    "g_injectXa_null_bX_differenceXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Difference(p["xx2"])}},
++    "g_injectX3_threeX_differenceXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Difference(p["xx2"])}},
      "g_injectXnullX_disjunctXinjectX1XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).Disjunct(gremlingo.T__.Inject(1))}}, 
      "g_V_valuesXnameX_disjunctXV_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Disjunct(gremlingo.T__.V().Fold())}}, 
      "g_V_fold_disjunctXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Disjunct(gremlingo.T__.Constant(nil))}}, 
      "g_V_fold_disjunctXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Disjunct(gremlingo.T__.V())}}, 
      "g_V_valuesXnameX_fold_disjunctX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(2)}}, 
-     "g_V_valuesXnameX_fold_disjunctX3varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(p["xx1"])}}, 
--    "g_V_valuesXnameX_fold_disjunctXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(nil)}}, 
++    "g_V_valuesXnameX_fold_disjunctX3varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(p["xx1"])}},
++    "g_V_valuesXnameX_fold_disjunctXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(nil)}},
      "g_V_valuesXnonexistantX_fold_disjunctXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Disjunct(gremlingo.T__.V().Values("name").Fold())}}, 
      "g_V_valuesXnameX_fold_disjunctXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(gremlingo.T__.V().Values("nonexistant").Fold())}}, 
      "g_V_valuesXageX_fold_disjunctXV_valuesXageX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold().Disjunct(gremlingo.T__.V().Values("age").Fold())}}, 
@@@ -876,8 -894,7 +905,8 @@@
      "g_VX1X_outEXknows_createdX_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows", "created").InV()}}, 
      "g_VX1X_outEXknowsX_bothV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").BothV()}}, 
      "g_VX1X_outEXknowsX_bothV_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").BothV().Values("name")}}, 
-     "g_V_toEXout_knowsvarX_valuesXweightX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ToE(gremlingo.Direction.Out, p["xx1"]).Values("weight")}}, 
--    "g_VX1X_properties_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).Properties().Element().Limit(1)}}, 
++    "g_V_toEXout_knowsvarX_valuesXweightX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ToE(gremlingo.Direction.Out, p["xx1"]).Values("weight")}},
++    "g_VX1X_properties_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).Properties().Element().Limit(1)}},
      "g_V_properties_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Element()}}, 
      "g_V_propertiesXageX_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties("age").Element()}}, 
      "g_EX_properties_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"]).Properties().Element().Limit(1)}}, 
@@@ -916,24 -933,23 +945,24 @@@
      "g_V_fold_intersectXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Intersect(gremlingo.T__.Constant(nil))}}, 
      "g_V_fold_intersectXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Intersect(gremlingo.T__.V())}}, 
      "g_V_valuesXnameX_fold_intersectX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(2)}}, 
-     "g_V_valuesXnameX_fold_intersectX5varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(p["xx1"])}}, 
--    "g_V_valuesXnameX_fold_intersectXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(nil)}}, 
++    "g_V_valuesXnameX_fold_intersectX5varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(p["xx1"])}},
++    "g_V_valuesXnameX_fold_intersectXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(nil)}},
      "g_V_valuesXnonexistantX_fold_intersectXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Intersect(gremlingo.T__.V().Values("name").Fold())}}, 
      "g_V_valuesXnameX_fold_intersectXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(gremlingo.T__.V().Values("nonexistant").Fold())}}, 
      "g_V_valuesXageX_fold_intersectXV_valuesXageX_foldX_order_local": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold().Intersect(gremlingo.T__.V().Values("age").Fold()).Order(gremlingo.Scope.Local)}}, 
      "g_V_out_path_byXvaluesXnameX_toUpperX_intersectXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Intersect([]interface{}{"MARKO"})}}, 
-     "g_injectXmarkoX_intersectX___V_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(gremlingo.T__.V().Values("name").Fold())}}, 
-     "g_V_valueMapXlocationX_selectXvaluesX_unfold_intersectXseattle_vancouverX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Intersect(p["xx1"])}}, 
 -    "g_injectXmarkoX_intersectX___V_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"marko"}).Intersect(gremlingo.T__.V().Values("name").Fold())}}, 
 -    "g_V_valueMapXlocationX_selectXvaluesX_unfold_intersectXseattle_vancouverX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Intersect([]interface{}{"seattle", "vancouver"})}}, 
++    "g_injectXmarkoX_intersectX___V_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(gremlingo.T__.V().Values("name").Fold())}},
++    "g_V_valueMapXlocationX_selectXvaluesX_unfold_intersectXseattle_vancouverX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Intersect(p["xx1"])}},
      "g_V_valuesXageX_fold_intersectX___constantX27X_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold().Intersect(gremlingo.T__.Constant(27).Fold())}}, 
-     "g_V_out_out_path_byXnameX_intersectXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Intersect(p["xx1"])}}, 
-     "g_injectXa_null_bX_intersectXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(p["xx2"])}}, 
-     "g_injectXa_null_bX_intersectXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(p["xx2"])}}, 
-     "g_injectX3_threeX_intersectXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(p["xx2"])}}, 
 -    "g_V_out_out_path_byXnameX_intersectXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Intersect([]interface{}{"dave", "kelvin"})}}, 
 -    "g_injectXa_null_bX_intersectXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Intersect([]interface{}{"a", "c"})}}, 
 -    "g_injectXa_null_bX_intersectXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Intersect([]interface{}{"a", nil, "c"})}}, 
 -    "g_injectX3_threeX_intersectXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{3, "three"}).Intersect([]interface{}{"five", "three", int32(7)})}}, 
++    "g_V_out_out_path_byXnameX_intersectXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Intersect(p["xx1"])}},
++    "g_injectXa_null_bX_intersectXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(p["xx2"])}},
++    "g_injectXa_null_bX_intersectXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(p["xx2"])}},
++    "g_injectX3_threeX_intersectXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Intersect(p["xx2"])}},
      "g_injectX__feature___test__nullX_lTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("  feature", " one test", nil, "", " ", " abc", "abc ", " abc ", "  ").LTrim()}}, 
      "g_injectX__feature___test__nullX_lTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"  feature  ", " one test ", nil, "", " ", " abc", "abc ", " abc ", "  "}).LTrim(gremlingo.Scope.Local)}}, 
      "g_injectX__feature__X_lTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("  feature  ").LTrim()}}, 
-     "g_injectXListXa_bXX_lTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).LTrim()}}, 
-     "g_injectXListX1_2XX_lTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).LTrim(gremlingo.Scope.Local)}}, 
 -    "g_injectXListXa_bXX_lTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", "b"}).LTrim()}}, 
 -    "g_injectXListX1_2XX_lTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2}).LTrim(gremlingo.Scope.Local)}}, 
++    "g_injectXListXa_bXX_lTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).LTrim()}},
++    "g_injectXListX1_2XX_lTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).LTrim(gremlingo.Scope.Local)}},
      "g_V_valuesXnameX_lTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   ripple   ").Prope [...]
      "g_V_valuesXnameX_order_fold_lTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   [...]
      "g_injectXfeature_test_nullX_length": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("feature", "test", nil).Length()}}, 
@@@ -1044,16 -1060,16 +1073,16 @@@
      "g_V_valuesXnonexistantX_fold_mergeXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Merge(gremlingo.T__.V().Values("name").Fold())}}, 
      "g_V_valuesXnameX_fold_mergeXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Merge(gremlingo.T__.V().Values("nonexistant").Fold())}}, 
      "g_V_valuesXageX_fold_mergeXV_valuesXageX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold().Merge(gremlingo.T__.V().Values("age").Fold())}}, 
-     "g_V_out_path_byXvaluesXnameX_toUpperX_mergeXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Merge(p["xx1"])}}, 
-     "g_injectXmarkoX_mergeXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(gremlingo.T__.V().Values("name").Fold())}}, 
-     "g_V_valueMapXlocationX_selectXvaluesX_unfold_mergeXseattle_vancouverX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Merge(p["xx1"])}}, 
-     "g_V_out_out_path_byXnameX_mergeXempty_listX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Merge(p["xx1"])}}, 
 -    "g_V_out_path_byXvaluesXnameX_toUpperX_mergeXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Merge([]interface{}{"MARKO"})}}, 
 -    "g_injectXmarkoX_mergeXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"marko"}).Merge(gremlingo.T__.V().Values("name").Fold())}}, 
 -    "g_V_valueMapXlocationX_selectXvaluesX_unfold_mergeXseattle_vancouverX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Merge([]interface{}{"seattle", "vancouver"})}}, 
 -    "g_V_out_out_path_byXnameX_mergeXempty_listX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Merge([]interface{}{})}}, 
++    "g_V_out_path_byXvaluesXnameX_toUpperX_mergeXMARKOX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Path().By(gremlingo.T__.Values("name").ToUpper()).Merge(p["xx1"])}},
++    "g_injectXmarkoX_mergeXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(gremlingo.T__.V().Values("name").Fold())}},
++    "g_V_valueMapXlocationX_selectXvaluesX_unfold_mergeXseattle_vancouverX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap("location").Select(gremlingo.Column.Values).Unfold().Merge(p["xx1"])}},
++    "g_V_out_out_path_byXnameX_mergeXempty_listX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Merge(p["xx1"])}},
      "g_V_valuesXageX_fold_mergeXconstantX27X_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold().Merge(gremlingo.T__.Constant(27).Fold())}}, 
-     "g_V_out_out_path_byXnameX_mergeXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Merge(p["xx1"])}}, 
-     "g_injectXa_null_bX_mergeXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(p["xx2"])}}, 
-     "g_injectXa_null_bX_mergeXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(p["xx2"])}}, 
-     "g_injectX3_threeX_mergeXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(p["xx2"])}}, 
-     "g_V_asXnameX_projectXnameX_byXnameX_mergeXother_blueprintX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("name").Project("name").By("name").Merge(p["xx1"])}}, 
 -    "g_V_out_out_path_byXnameX_mergeXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Merge([]interface{}{"dave", "kelvin"})}}, 
 -    "g_injectXa_null_bX_mergeXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Merge([]interface{}{"a", "c"})}}, 
 -    "g_injectXa_null_bX_mergeXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", nil, "b"}).Merge([]interface{}{"a", nil, "c"})}}, 
 -    "g_injectX3_threeX_mergeXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{3, "three"}).Merge([]interface{}{"five", "three", int32(7)})}}, 
 -    "g_V_asXnameX_projectXnameX_byXnameX_mergeXother_blueprintX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("name").Project("name").By("name").Merge(map[interface{}]interface{}{"other": "blueprint" })}}, 
++    "g_V_out_out_path_byXnameX_mergeXdave_kelvinX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Path().By("name").Merge(p["xx1"])}},
++    "g_injectXa_null_bX_mergeXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(p["xx2"])}},
++    "g_injectXa_null_bX_mergeXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(p["xx2"])}},
++    "g_injectX3_threeX_mergeXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Merge(p["xx2"])}},
++    "g_V_asXnameX_projectXnameX_byXnameX_mergeXother_blueprintX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("name").Project("name").By("name").Merge(p["xx1"])}},
      "g_V_hasXname_markoX_elementMap_mergeXV_hasXname_lopX_elementMapX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "marko").ElementMap().Merge(gremlingo.T__.V().Has("name", "lop").ElementMap())}}, 
      "g_V_mergeEXlabel_selfX_optionXonMatch_emptyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddE("self")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{ })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *grem [...]
      "g_V_mergeEXlabel_selfX_optionXonMatch_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddE("self")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch, nil)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return [...]
@@@ -1076,7 -1092,7 +1105,7 @@@
      "g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnCrea [...]
      "g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1 [...]
      "g_V_hasXperson_name_marko_X_mergeEXlabel_knowsX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo [...]
-     "g_injectXlabel_knows_out_marko_in_vadasX_mergeE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).MergeE()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", [...]
 -    "g_withSideEffectXlabel_knows_out_marko_in_vadasX_injectX1X_selectXmX_mergeE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).Select("m").MergeE()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTrav [...]
++    "g_injectXlabel_knows_out_marko_in_vadasX_mergeE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).MergeE()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", [...]
      "g_mergeEXlabel_knows_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("b").To("a").Property("created", "Y")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *g [...]
      "g_mergeEXlabel_knows_out_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("b").To("a").Property("created", "Y")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) * [...]
      "g_mergeEXout_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("created", "Y").AddE("knows").From("b").To("a").Property("created", "Y")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.Gr [...]
@@@ -1085,7 -1101,7 +1114,7 @@@
      "g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_selectXmXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlin [...]
      "g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko1_in_vadas1X_optionXonCreate_selectXcXX_optionXonMatch_selectXmXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(greml [...]
      "g_mergeEXlabel_knows_out_marko_in_vadasX_aliased_direction": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person [...]
-     "g_injectXlabel_knows_out_marko_in_vadas_label_self_out_vadas_in_vadasX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).MergeE()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTrav [...]
 -    "g_withSideEffectXm1_label_knows_out_marko_in_vadas_m2_label_self_out_vadas_in_vadasX_unionXselectXm1X_selectXm2XX_mergeE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Union(gremlingo.T__.Select("m1"), gremlingo.T__.Select("m2")).MergeE()}, f [...]
++    "g_injectXlabel_knows_out_marko_in_vadas_label_self_out_vadas_in_vadasX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).MergeE()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTrav [...]
      "g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_sideEffectXpropertiesXweightX_dropX_selectXmXX_exists": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1.0).From("a").To("b")}, func(g *gremlingo.GraphTraversalSo [...]
      "g_mergeE_with_outVinV_options_map": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OutV, p["xx2"]).Option(gremlingo.Merge.InV, p["xx3"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) [...]
      "g_mergeE_inline_with_outVinV_options_map": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(map[interface{}]interface{}{gremlingo.Direction.Out: gremlingo.Merge.OutV, gremlingo.Direction.In: gremlingo.Merge.InV, gremlingo.T.Label: "knows"  [...]
@@@ -1100,10 -1116,10 +1129,10 @@@
      "g_mergeV_mergeE_combination_new_vertices": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).As("outV").MergeV(p["xx2"]).As("inV").MergeE(p["xx3"]).Option(gremlingo.Merge.OutV, gremlingo.T__.Select("outV")).Option(gremlingo.Merge.InV, gremlingo.T__.Select("inV"))}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p  [...]
      "g_mergeV_mergeE_combination_existing_vertices": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).As("outV").MergeV(p["xx2"]).As("inV").MergeE(p["xx3"]).Option(gremlingo.Merge.OutV, gremlingo.T__.Select("outV")).Option(gremlingo.M [...]
      "g_V_asXvX_mergeEXxx1X_optionXMerge_onMatch_xx2X_optionXMerge_outV_selectXvXX_optionXMerge_inV_selectXvXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("v").MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"]).Option(gremlingo.Merge.OutV, gremlingo.T [...]
-     "g_V_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(p["xx1"] [...]
 -    "g_V_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(p["xx1"] [...]
++    "g_V_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(p["xx1"] [...]
      "g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Opti [...]
-     "g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Propert [...]
-     "g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Proper [...]
 -    "g_unionXselectXmX_selectXmX_constantXcreated_NXX_fold_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java"). [...]
 -    "g_unionXselectXmX_selectXmX_constantXcreated_NXX_fold_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java") [...]
++    "g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Propert [...]
++    "g_injectXlist1_list2X_mergeEXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Proper [...]
      "g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_weight_nullX_allowed": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("weight", 1.0)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatc [...]
      "g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_weight_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("weight", 1.0)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx [...]
      "g_mergeVXemptyX_optionXonMatch_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{ }).Option(gremlingo.Merge.OnMatch, nil)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g [...]
@@@ -1135,13 -1151,13 +1164,13 @@@
      "g_withSideEffectXc_label_person_name_stephenX_withSideEffectXm_label_person_name_stephen_age_19X_injectX0X_mergeVXselectXcXX_optionXonCreate_selectXmXX_option": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(0).MergeV(gremlingo.T__.Select("c")).Option(gremli [...]
      "g_withSideEffectXc_label_person_name_markoX_withSideEffectXm_age_19X_injectX0X_mergeVXselectXcXX_optionXonMatch_selectXmXX_option": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(0).MergeV(gremlingo.T__.Select("c")).Option(gremlingo.Merge.OnMatch, gremlingo. [...]
      "g_injectX0X_mergeVXlabel_person_name_markoX_propertyXname_vadas_acl_publicX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(0).MergeV(p["xx1"]).Property("name", "vadas", "acl", "public")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *g [...]
-     "g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeVXidentityX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).MergeV(gremlingo.T__.Identity())}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo. [...]
-     "g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).MergeV()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has(" [...]
 -    "g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeVXidentityX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "marko" }, map[interface{}]interface{}{gremlingo.T.Label: "person", [...]
 -    "g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "marko" }, map[interface{}]interface{}{gremlingo.T.Label: "person", "name": " [...]
++    "g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeVXidentityX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).MergeV(gremlingo.T__.Identity())}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo. [...]
++    "g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).MergeV()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has(" [...]
      "g_mergeVXlabel_person_name_stephenX_propertyXlist_name_steveX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property(gremlingo.Cardinality.List, "name", "stephen")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Property(gremlingo.Cardinality.List, "name", "steve")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *grem [...]
      "g_mergeXlabel_person_name_vadasX_optionXonMatch_age_35X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "vadas").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"])}, func(g *gremlingo.GraphTraversalSource [...]
      "g_V_mapXmergeXlabel_person_name_joshXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "vadas").Property("age", 29).AddV("person").Property("name", "stephen").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Map(gremlingo.T__.MergeV(p["xx1"]))}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *greml [...]
      "g_withSideEffectXc_label_person_name_markoX_withSideEffectXm_age_19X_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property(gremlingo.Cardinality.List, "age", 29).Property(gremlingo.Cardinality.List, "age", 31).Property(gremlingo.Cardinality.List, "age", 32)}, func(g *gremlingo.GraphTraversalSource, p [...]
-     "g_withSideEffectXm_age_19X_V_hasXperson_name_markoX_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property(gremlingo.Cardinality.List, "age", 29).Property(gremlingo.Cardinality.List, "age", 31).Property(gremlingo.Cardinality.List, "age", 32)}, func(g *gremlingo.GraphTraversalSource, p map[string]inter [...]
 -    "g_withSideEffectXm_age_19X_V_hasXperson_name_markoX_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property(gremlingo.Cardinality.List, "age", 29).Property(gremlingo.Cardinality.List, "age", 31).Property(gremlingo.Cardinality.List, "age", 32)}, func(g *gremlingo.GraphTraversalSource, p map[string]inter [...]
++    "g_withSideEffectXm_age_19X_V_hasXperson_name_markoX_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property(gremlingo.Cardinality.List, "age", 29).Property(gremlingo.Cardinality.List, "age", 31).Property(gremlingo.Cardinality.List, "age", 32)}, func(g *gremlingo.GraphTraversalSource, p map[string]inter [...]
      "g_mergeV_onCreate_inheritance_existing": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "mike").Property(gremlingo.T.Id, "1")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnCreate, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()} [...]
      "g_mergeV_onCreate_inheritance_new_1": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnCreate, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V("1").Has("person", "name", "mike")}}, 
      "g_mergeV_onCreate_inheritance_new_2": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnCreate, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V("1").Has("person", "name", "mike")}}, 
@@@ -1166,10 -1182,8 +1195,10 @@@
      "g_mergeVXname_aliceX_optionXonCreate_age_setX81XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{"name": "alice", gremlingo.T.Label: "person" }).Option(gremlingo.Merge.OnCreate, map[interface{}]interface{}{"age": gremlingo.CardinalityValue.Set(81) })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", "alice").Has [...]
      "g_mergeVXname_aliceX_optionXonCreate_age_singleX81X_age_81_setX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{"name": "alice", gremlingo.T.Label: "person" }).Option(gremlingo.Merge.OnCreate, map[interface{}]interface{}{"age": 81 }, gremlingo.Cardinality.Set)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", "al [...]
      "g_mergeV_hidden_label_key_onMatch_matched_prohibited": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{ }).Option(gremlingo.Merge.OnMatch, p["xx1"])}}, 
-     "g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV(gremlingo.T__.Select [...]
-     "g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV(gremlingo.T__.Selec [...]
-     "g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX_allowed": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.Grap [...]
-     "g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTravers [...]
 -    "g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "marko" [...]
 -    "g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "steph [...]
++    "g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV(gremlingo.T__.Select [...]
++    "g_injectXlist1_list2X_mergeVXlimitXlocal_1X_unfoldX_optionXonCreate_rangeXlocal_1_2X_unfoldX_optionXonMatch_tailXlocalX_unfoldX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV(gremlingo.T__.Selec [...]
++    "g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX_allowed": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.Grap [...]
++    "g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTravers [...]
      "g_V_age_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Min()}}, 
      "g_V_foo_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("foo").Min()}}, 
      "g_V_name_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Min()}}, 
@@@ -1243,8 -1257,7 +1272,8 @@@
      "g_V_fold_productXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Product(gremlingo.T__.Constant(nil))}}, 
      "g_V_fold_productXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Product(gremlingo.T__.V())}}, 
      "g_V_valuesXnameX_fold_productX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(2)}}, 
-     "g_V_valuesXnameX_fold_productX7varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(p["xx1"])}}, 
--    "g_V_valuesXnameX_fold_productXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(nil)}}, 
++    "g_V_valuesXnameX_fold_productX7varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(p["xx1"])}},
++    "g_V_valuesXnameX_fold_productXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(nil)}},
      "g_V_valuesXnonexistantX_fold_productXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Product(gremlingo.T__.V().Values("name").Fold())}}, 
      "g_V_valuesXnameX_fold_productXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(gremlingo.T__.V().Values("nonexistant").Fold())}}, 
      "g_V_valuesXageX_order_byXdescX_limitX3X_fold_productXV_valuesXageX_order_byXascX_limitX2X_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Order().By(gremlingo.Order.Desc).Limit(3).Fold().Product(gremlingo.T__.V().Values("age").Order().By(gremlingo.Order.Asc).Limit(2).Fold()).Unfold()}}, 
@@@ -1269,8 -1282,8 +1298,8 @@@
      "g_injectX__feature___test__nullX_rTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("feature  ", "one test ", nil, "", " ", " abc", "abc ", " abc ", "  ").RTrim()}}, 
      "g_injectX__feature___test__nullX_rTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"  feature  ", " one test ", nil, "", " ", " abc", "abc ", " abc ", "  "}).RTrim(gremlingo.Scope.Local)}}, 
      "g_injectX__feature__X_rTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("  feature  ").RTrim()}}, 
-     "g_injectXListXa_bXX_rTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).RTrim()}}, 
-     "g_injectXListX1_2XX_rTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).RTrim(gremlingo.Scope.Local)}}, 
 -    "g_injectXListXa_bXX_rTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", "b"}).RTrim()}}, 
 -    "g_injectXListX1_2XX_rTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2}).RTrim(gremlingo.Scope.Local)}}, 
++    "g_injectXListXa_bXX_rTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).RTrim()}},
++    "g_injectXListX1_2XX_rTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).RTrim(gremlingo.Scope.Local)}},
      "g_V_valuesXnameX_rTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   ripple   ").Prope [...]
      "g_V_valuesXnameX_order_fold_rTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   [...]
      "g_injectXthat_this_test_nullX_replaceXh_jX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("that", "this", "test", nil).Replace("h", "j")}}, 
@@@ -1288,7 -1301,7 +1317,7 @@@
      "g_V_valuesXnameX_fold_orderXlocalX_by_reverse": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Order(gremlingo.Scope.Local).By().Reverse()}}, 
      "g_injectXnullX_reverse": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).Reverse()}}, 
      "g_injectXbX_reverse": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("b").Reverse()}}, 
-     "g_injectX3_threeX_reverse": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Reverse()}}, 
 -    "g_injectX3_threeX_reverse": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{3, "three"}).Reverse()}}, 
++    "g_injectX3_threeX_reverse": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Reverse()}},
      "g_VX1X_asXaX_outXknowsX_asXbX_selectXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("a").Out("knows").As("b").Select("a", "b")}}, 
      "g_VX1X_asXaX_outXknowsX_asXbX_selectXa_bX_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("a").Out("knows").As("b").Select("a", "b").By("name")}}, 
      "g_VX1X_asXaX_outXknowsX_asXbX_selectXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("a").Out("knows").As("b").Select("a")}}, 
@@@ -1356,7 -1369,7 +1385,7 @@@
      "g_withStrategiesXProductiveByStrategyX_V_asXaX_selectXaX_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ProductiveByStrategy()).V().As("a").Select("a").By("age")}}, 
      "g_withSideEffectXk_nullX_injectXxX_selectXkX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("k", nil).Inject("x").Select("k")}}, 
      "g_V_out_in_selectXall_a_a_aX_byXunfold_name_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("A").Property("name", "a1").As("a1").AddV("B").Property("name", "b1").As("b1").AddE("ab").From("a1").To("b1")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").In().As("a").Select(gremlingo.Pop.All, "a", "a", "a").By(gremlingo.T__.Unfold().Values [...]
-     "g_withoutStrategiesXLazyBarrierStrategyX_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.LazyBarrierStrategy()).V().As("label").Aggregate(gremlingo.Scope.Local, "x").Select("x").Select("label")}}, 
 -    "g_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("label").Aggregate(gremlingo.Scope.Local, "x").Barrier().Select("x").Select("label")}}, 
++    "g_withoutStrategiesXLazyBarrierStrategyX_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.LazyBarrierStrategy()).V().As("label").Aggregate(gremlingo.Scope.Local, "x").Select("x").Select("label")}},
      "g_V_name_asXaX_selectXfirst_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").As("a").Select(gremlingo.Pop.First, "a")}}, 
      "g_V_name_asXaX_selectXlast_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").As("a").Select(gremlingo.Pop.Last, "a")}}, 
      "g_V_name_asXaX_selectXmixed_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").As("a").Select(gremlingo.Pop.Mixed, "a")}}, 
@@@ -1386,12 -1399,12 +1415,12 @@@
      "g_injectXthat_this_testX_spiltXhX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("that", "this", "test", nil).Split("h")}}, 
      "g_injectXhello_worldX_spiltXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("hello world").Split(nil)}}, 
      "g_injectXthat_this_test_nullX_splitXemptyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("that", "this", "test", nil).Split("")}}, 
-     "g_injectXListXa_bXcX_splitXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Split("a")}}, 
 -    "g_injectXListXa_bXcX_splitXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", "b"}).Split("a")}}, 
++    "g_injectXListXa_bXcX_splitXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Split("a")}},
      "g_V_hasLabelXpersonX_valueXnameX_splitXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").Split(nil)}}, 
      "g_V_hasLabelXpersonX_valueXnameX_order_fold_splitXlocal_aX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").Order().Fold().Split(gremlingo.Scope.Local, "a").Unfold()}}, 
      "g_V_hasLabelXpersonX_valueXnameX_order_fold_splitXlocal_emptyX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").Order().Fold().Split(gremlingo.Scope.Local, "").Unfold()}}, 
      "g_injectXthat_this_testX_substringX1_8X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("test", "hello world", nil).Substring(1, 8)}}, 
-     "g_injectXListXa_bXcX_substringX1_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Substring(1, 2)}}, 
 -    "g_injectXListXa_bXcX_substringX1_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"aa", "bb"}).Substring(1, 2)}}, 
++    "g_injectXListXa_bXcX_substringX1_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Substring(1, 2)}},
      "g_V_hasLabelXpersonX_valueXnameX_substringX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("software").Values("name").Substring(2)}}, 
      "g_V_hasLabelXsoftwareX_valueXnameX_substringX1_4X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("software").Values("name").Substring(1, 4)}}, 
      "g_V_hasLabelXpersonX_valueXnameX_order_fold_substringXlocal_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("software").Values("name").Order().Fold().Substring(gremlingo.Scope.Local, 2)}}, 
@@@ -1435,8 -1448,8 +1464,8 @@@
      "g_injectX1b_26b_3iX_fold_sumXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(int8(1), int8(2), int32(3)).Fold().Sum(gremlingo.Scope.Local)}}, 
      "g_injectX1f_26f_3fX_fold_sumXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(float32(1), float32(2), float32(3)).Fold().Sum(gremlingo.Scope.Local)}}, 
      "g_injectXfeature_test_nullX_toLower": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("FEATURE", "tESt", nil).ToLower()}}, 
-     "g_injectXfeature_test_nullX_toLowerXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).ToLower(gremlingo.Scope.Local)}}, 
-     "g_injectXListXa_bXX_toLower": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).ToLower()}}, 
 -    "g_injectXfeature_test_nullX_toLowerXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"FEATURE", "tESt", nil}).ToLower(gremlingo.Scope.Local)}}, 
 -    "g_injectXListXa_bXX_toLower": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", "b"}).ToLower()}}, 
++    "g_injectXfeature_test_nullX_toLowerXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).ToLower(gremlingo.Scope.Local)}},
++    "g_injectXListXa_bXX_toLower": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).ToLower()}},
      "g_V_valuesXnameX_toLower": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "MARKO").Property("age", 29).As("marko").AddV("person").Property("name", "VADAS").Property("age", 27).As("vadas").AddV("software").Property("name", "LOP").Property("lang", "java").As("lop").AddV("person").Property("name", "JOSH").Property("age", 32).As("josh").AddV("software").Property("name", "RIPPLE").Property("lang", "j [...]
      "g_V_valuesXnameX_toLowerXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "MARKO").Property("age", 29).As("marko").AddV("person").Property("name", "VADAS").Property("age", 27).As("vadas").AddV("software").Property("name", "LOP").Property("lang", "java").As("lop").AddV("person").Property("name", "JOSH").Property("age", 32).As("josh").AddV("software").Property("name", "RIPPLE").Property("la [...]
      "g_V_valuesXnameX_order_fold_toLowerXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "MARKO").Property("age", 29).As("marko").AddV("person").Property("name", "VADAS").Property("age", 27).As("vadas").AddV("software").Property("name", "LOP").Property("lang", "java").As("lop").AddV("person").Property("name", "JOSH").Property("age", 32).As("josh").AddV("software").Property("name", "RIPPLE").P [...]
@@@ -1582,14 -1595,10 +1611,14 @@@
      "InjectX1dX_notXerrorX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).Not(gremlingo.T__.Is(gremlingo.P.Gt(math.NaN())))}}, 
      "InjectX1dX_notXisXeqXNaNXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).Not(gremlingo.T__.Is(gremlingo.P.Eq(math.NaN())))}}, 
      "InjectXInfX_eqXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Eq(math.Inf(1)))}}, 
-     "InjectXInfArgX_eqXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Eq(math.Inf(1)))}}, 
--    "InjectXInfX_neqXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Neq(math.Inf(1)))}}, 
-     "InjectXInfArgX_neqXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Neq(math.Inf(1)))}}, 
--    "InjectXNegInfX_eqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Eq(math.Inf(-1)))}}, 
-     "InjectXNegInfArgX_eqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Eq(math.Inf(-1)))}}, 
--    "InjectXNegInfX_neqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Neq(math.Inf(-1)))}}, 
-     "InjectXNegInfArgX_neqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Neq(math.Inf(-1)))}}, 
--    "InjectXInfX_gtXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Gt(math.Inf(-1)))}}, 
++    "InjectXInfArgX_eqXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Eq(math.Inf(1)))}},
++    "InjectXInfX_neqXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Neq(math.Inf(1)))}},
++    "InjectXInfArgX_neqXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Neq(math.Inf(1)))}},
++    "InjectXNegInfX_eqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Eq(math.Inf(-1)))}},
++    "InjectXNegInfArgX_eqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Eq(math.Inf(-1)))}},
++    "InjectXNegInfX_neqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Neq(math.Inf(-1)))}},
++    "InjectXNegInfArgX_neqXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Neq(math.Inf(-1)))}},
++    "InjectXInfX_gtXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Gt(math.Inf(-1)))}},
      "InjectXInfX_ltXNegInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(1)).Is(gremlingo.P.Lt(math.Inf(-1)))}}, 
      "InjectXNegInfX_ltXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Lt(math.Inf(1)))}}, 
      "InjectXNegInfX_gtXInfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(math.Inf(-1)).Is(gremlingo.P.Gt(math.Inf(1)))}}, 
@@@ -1604,18 -1613,11 +1633,18 @@@
      "g_V_values_order": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values().Order()}}, 
      "g_V_properties_order": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Order()}}, 
      "g_V_properties_order_id": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Order().Id()}}, 
 -    "g_E_properties_order_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5).Property("a", int32(10)).AddE("self").From("a").To("a").Property("weight", 1.0).Property("a", int32(11)).AddE("self").From("a").To("a").Property("weight", 0.4).Property("a", int32(12)).AddE("self").From("a").To("a").Property("weight", 1.0).Property(" [...]
 +<<<<<<< HEAD
-     "g_E_properties_order_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().Properties().Order().Value()}}, 
-     "g_E_properties_order_byXdescX_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().Properties().Order().By(gremlingo.Order.Desc).Value()}}, 
-     "g_inject_order": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order()}}, 
-     "g_inject_order_byXdescX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order().By(gremlingo.Order.Desc)}}, 
++    "g_E_properties_order_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().Properties().Order().Value()}},
++    "g_E_properties_order_byXdescX_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().Properties().Order().By(gremlingo.Order.Desc).Value()}},
++    "g_inject_order": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order()}},
++    "g_inject_order_byXdescX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx8"], p["xx7"], p["xx10"], p["xx4"], p["xx9"], p["xx12"], p["xx1"], p["xx5"], p["xx11"], p["xx6"], p["xx3"], p["xx2"], p["xx13"], p["xx14"], p["xx15"]).Order().By(gremlingo.Order.Desc)}},
 +=======
-     "g_E_properties_order_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5).Property("a", int32(10)).AddE("self").From("a").To("a").Property("weight", 1.0).Property("a", int32(11)).AddE("self").From("a").To("a").Property("weight", 0.4).Property("a", int32(12)).AddE("self").From("a").To("a").Property("weight", 1.0).Property(" [...]
++    "g_E_properties_order_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5).Property("a", int32(10)).AddE("self").From("a").To("a").Property("weight", 1.0).Property("a", int32(11)).AddE("self").From("a").To("a").Property("weight", 0.4).Property("a", int32(12)).AddE("self").From("a").To("a").Property("weight", 1.0).Property(" [...]
      "g_E_properties_order_byXdescX_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "alice").As("a").AddE("self").From("a").To("a").Property("weight", 0.5).Property("a", int32(10)).AddE("self").From("a").To("a").Property("weight", 1.0).Property("a", int32(11)).AddE("self").From("a").To("a").Property("weight", 0.4).Property("a", int32(12)).AddE("self").From("a").To("a").Property("weight", 1.0).P [...]
      "g_inject_order": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("zzz", "foo", []interface{}{"a", "b", "c", "d"}, 1, []interface{}{"a", "b", "c"}, map[interface{}]interface{}{"a": "a", "b": "b" }, nil, 2.0, map[interface{}]interface{}{"a": "a", "b": false, "c": "c" }, "bar", true, false, math.Inf(1), math.NaN(), math.Inf(-1)).Order()}}, 
      "g_inject_order_byXdescX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("zzz", "foo", []interface{}{"a", "b", "c", "d"}, 1, []interface{}{"a", "b", "c"}, map[interface{}]interface{}{"a": "a", "b": "b" }, nil, 2.0, map[interface{}]interface{}{"a": "a", "b": false, "c": "c" }, "bar", true, false, math.Inf(1), math.NaN(), math.Inf(-1)).Order().By(gremlingo.Order.Desc)}}, 
 -    "g_V_out_out_order_byXascX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Order().By(gremlingo.Order.Asc)}}, 
 +>>>>>>> 3.8-dev
-     "g_V_out_out_order_byXascX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Order().By(gremlingo.Order.Asc)}}, 
++    "g_V_out_out_order_byXascX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Order().By(gremlingo.Order.Asc)}},
      "g_V_out_out_order_byXdescX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Order().By(gremlingo.Order.Desc)}}, 
      "g_V_out_out_asXheadX_path_order_byXascX_selectXheadX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().As("head").Path().Order().By(gremlingo.Order.Asc).Select("head")}}, 
      "g_V_out_out_asXheadX_path_order_byXdescX_selectXheadX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().As("head").Path().Order().By(gremlingo.Order.Desc).Select("head")}}, 
@@@ -1727,15 -1729,10 +1756,15 @@@
      "g_VX1X_valuesXageX_inject": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["xx1"]).Values("age").Inject()}}, 
      "g_injectXnull_1_3_nullX_asXaX_selectXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, 1, 3, nil).As("a").Select("a")}}, 
      "g_injectX1_3X_injectX100_300X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1, 3).Inject(100, 300)}}, 
-     "g_injectX1var_3varX_injectX100var_300varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).Inject(p["xx3"], p["xx4"])}}, 
--    "g_injectX1_3_100_300X_list": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 3, 100, 300})}}, 
-     "g_injectX1_3_100_300X_listvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}}, 
--    "g_injectX1_3_100_300X_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.NewSimpleSet(1, 3, 100, 300))}}, 
-     "g_injectX1_3_100_300X_setvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}}, 
--    "g_injectX1_1X_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.NewSimpleSet(1, 1))}}, 
-     "g_injectX1_1X_setvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}}, 
-     "g_injectX_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}}, 
--    "g_io_readXkryoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.kryo").Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}}, 
++    "g_injectX1var_3varX_injectX100var_300varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).Inject(p["xx3"], p["xx4"])}},
++    "g_injectX1_3_100_300X_list": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 3, 100, 300})}},
++    "g_injectX1_3_100_300X_listvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
++    "g_injectX1_3_100_300X_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.NewSimpleSet(1, 3, 100, 300))}},
++    "g_injectX1_3_100_300X_setvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
++    "g_injectX1_1X_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.NewSimpleSet(1, 1))}},
++    "g_injectX1_1X_setvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
++    "g_injectX_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
++    "g_io_readXkryoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.kryo").Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}},
      "g_io_read_withXreader_gryoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.kryo").With(gremlingo.IO.Reader, gremlingo.IO.Gryo).Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}}, 
      "g_io_readXgraphsonX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.json").Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}}, 
      "g_io_read_withXreader_graphsonX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.json").With(gremlingo.IO.Reader, gremlingo.IO.Graphson).Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}}, 
diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.ts
index 99ffc65f2d,7edcfe1085..1847b22e60
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.ts
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.ts
@@@ -473,6 -453,16 +473,16 @@@ export class GraphTraversal extends Tra
      return this;
    }
  
+   /**
+    * Graph traversal asNumber method.
+    * @param {...Object} args
+    * @returns {GraphTraversal}
+    */
 -  asNumber(...args) {
++  asNumber(...args: any[]) {
+     this.bytecode.addStep('asNumber', args);
+     return this;
+   }
+ 
    /**
     * Graph traversal asString method.
     * @param {...Object} args
diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.ts
index 3a62e758f5,44f1f34528..299c930ee0
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.ts
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.ts
@@@ -502,17 -506,28 +502,18 @@@ export class EnumValue 
    }
  }
  
 -module.exports = {
 -  EnumValue,
 -  P,
 -  TextP,
 -  withOptions,
 -  IO,
 -  Traversal,
 -  TraversalSideEffects,
 -  Traverser,
 -  barrier: toEnum('Barrier', 'normSack'),
 -  cardinality: toEnum('Cardinality', 'list set single'),
 -  column: toEnum('Column', 'keys values'),
 -  direction: toDirectionEnum('Direction', 'BOTH IN OUT from_ to'),
 -  dt: toEnum('DT', 'second minute hour day'),
 -  n: toNEnum('N', 'byte_ short_ int_ long_ float_ double_ bigInt bigDecimal'),
 -  graphSONVersion: toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0'),
 -  gryoVersion: toEnum('GryoVersion', 'V1_0 V3_0'),
 -  merge: toEnum('Merge', 'onCreate onMatch outV inV'),
 -  operator: toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong'),
 -  order: toEnum('Order', 'asc desc shuffle'),
 -  pick: toEnum('Pick', 'any none unproductive'),
 -  pop: toEnum('Pop', 'all first last mixed'),
 -  scope: toEnum('Scope', 'global local'),
 -  t: toEnum('T', 'id key label value'),
 -};
 +export const barrier = toEnum('Barrier', 'normSack');
 +export const cardinality = toEnum('Cardinality', 'list set single');
 +export const column = toEnum('Column', 'keys values');
 +export const direction = toDirectionEnum('Direction', 'BOTH IN OUT from_ to');
 +export const dt = toEnum('DT', 'second minute hour day');
 +export const graphSONVersion = toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0');
 +export const gryoVersion = toEnum('GryoVersion', 'V1_0 V3_0');
 +export const merge = toEnum('Merge', 'onCreate onMatch outV inV');
 +export const operator = toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong');
 +export const order = toEnum('Order', 'asc desc shuffle');
 +export const pick = toEnum('Pick', 'any none unproductive');
 +export const pop = toEnum('Pop', 'all first last mixed');
 +export const scope = toEnum('Scope', 'global local');
 +export const t = toEnum('T', 'id key label value');
++export const n = toEnum('N', 'byte_ short_ int_ long_ float_ double_ bigInt bigDecimal');
diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/EnumSerializer.js
index b00ced08de,bb11c65cf8..43b4b50f84
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/EnumSerializer.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/EnumSerializer.js
@@@ -20,25 -20,12 +20,26 @@@
  /**
   * @author Igor Ostapenko
   */
 -'use strict';
  
 -const { Buffer } = require('buffer');
 -const t = require('../../../../process/traversal');
 -
 -module.exports = class EnumSerializer {
 +import { Buffer } from 'buffer';
 +import {
 +  barrier,
 +  cardinality,
 +  column,
 +  direction,
 +  dt,
 +  merge,
 +  operator,
 +  order,
 +  pick,
 +  pop,
 +  scope,
 +  t as _t,
++  n as _n,
 +  EnumValue,
 +} from '../../../../process/traversal.js';
 +
 +export default class EnumSerializer {
    constructor(ioc) {
      this.ioc = ioc;
  
@@@ -51,18 -38,19 +52,19 @@@
      };
      const DT = ioc.DataType;
      this.types = [
 -      { name: 'Barrier', code: DT.BARRIER, enum: to_orig_enum(t.barrier) },
 -      { name: 'Cardinality', code: DT.CARDINALITY, enum: to_orig_enum(t.cardinality) },
 -      { name: 'Column', code: DT.COLUMN, enum: to_orig_enum(t.column) },
 -      { name: 'Direction', code: DT.DIRECTION, enum: to_orig_enum(t.direction) },
 -      { name: 'DT', code: DT.DT, enum: to_orig_enum(t.dt) },
 -      { name: 'Merge', code: DT.MERGE, enum: to_orig_enum(t.merge) },
 -      { name: 'N', code: DT.N, enum: to_orig_enum(t.n) },
 -      { name: 'Operator', code: DT.OPERATOR, enum: to_orig_enum(t.operator) },
 -      { name: 'Order', code: DT.ORDER, enum: to_orig_enum(t.order) },
 -      { name: 'Pick', code: DT.PICK, enum: to_orig_enum(t.pick) },
 -      { name: 'Pop', code: DT.POP, enum: to_orig_enum(t.pop) },
 -      { name: 'Scope', code: DT.SCOPE, enum: to_orig_enum(t.scope) },
 -      { name: 'T', code: DT.T, enum: to_orig_enum(t.t) },
 +      { name: 'Barrier', code: DT.BARRIER, enum: to_orig_enum(barrier) },
 +      { name: 'Cardinality', code: DT.CARDINALITY, enum: to_orig_enum(cardinality) },
 +      { name: 'Column', code: DT.COLUMN, enum: to_orig_enum(column) },
 +      { name: 'Direction', code: DT.DIRECTION, enum: to_orig_enum(direction) },
 +      { name: 'DT', code: DT.DT, enum: to_orig_enum(dt) },
 +      { name: 'Merge', code: DT.MERGE, enum: to_orig_enum(merge) },
 +      { name: 'Operator', code: DT.OPERATOR, enum: to_orig_enum(operator) },
 +      { name: 'Order', code: DT.ORDER, enum: to_orig_enum(order) },
 +      { name: 'Pick', code: DT.PICK, enum: to_orig_enum(pick) },
 +      { name: 'Pop', code: DT.POP, enum: to_orig_enum(pop) },
 +      { name: 'Scope', code: DT.SCOPE, enum: to_orig_enum(scope) },
 +      { name: 'T', code: DT.T, enum: to_orig_enum(_t) },
++      { name: 'N', code: DT.N, enum: to_orig_enum(_n) },
      ];
      this.byname = {};
      this.bycode = {};
diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
index de011df072,3eb709e247..3675fe3aa3
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
@@@ -720,16 -719,40 +721,40 @@@ const gremlins = 
      g_injectXstrX_asDate: [function({g}) { return g.inject("2023-08-02T00:00:00Z").asDate() }], 
      g_injectXstr_offsetX_asDate: [function({g}) { return g.inject("2023-08-02T00:00:00-07:00").asDate() }], 
      g_injectX1694017707000X_asDate: [function({g}) { return g.inject(1694017707000).asDate() }], 
 -    g_injectX1694017708000LX_asDate: [function({g}) { return g.inject(1694017708000).asDate() }], 
 -    g_injectX1694017709000dX_asDate: [function({g}) { return g.inject(1694017709000.1).asDate() }], 
 -    g_injectX1_2X_asDate: [function({g}) { return g.inject([1, 2]).asDate() }], 
 +    g_injectX1694017708000LX_asDate: [function({g, xx1}) { return g.inject(xx1).asDate() }], 
 +    g_injectX1694017709000dX_asDate: [function({g, xx1}) { return g.inject(xx1).asDate() }], 
 +    g_injectX1_2X_asDate: [function({g, xx1}) { return g.inject(xx1).asDate() }], 
      g_injectXnullX_asDate: [function({g}) { return g.inject(null).asDate() }], 
      g_injectXinvalidstrX_asDate: [function({g}) { return g.inject("This String is not an ISO 8601 Date").asDate() }], 
+     g_injectX5bX_asNumber: [function({g}) { return g.inject(5).asNumber() }], 
+     g_injectX5sX_asNumber: [function({g}) { return g.inject(5).asNumber() }], 
+     g_injectX5iX_asNumber: [function({g}) { return g.inject(5).asNumber() }], 
+     g_injectX5lX_asNumber: [function({g}) { return g.inject(5).asNumber() }], 
+     g_injectX5nX_asNumber: [function({g}) { return g.inject(5).asNumber() }], 
+     g_injectX5_0X_asNumber: [function({g}) { return g.inject(5.0).asNumber() }], 
+     g_injectX5_75fX_asNumber: [function({g}) { return g.inject(5.75).asNumber() }], 
+     g_injectX5_43X_asNumberXN_intX: [function({g}) { return g.inject(5.43).asNumber(N.int_) }], 
+     g_injectX5_67X_asNumberXN_intX: [function({g}) { return g.inject(5.67).asNumber(N.int_) }], 
+     g_injectX5X_asNumberXN_longX: [function({g}) { return g.inject(5).asNumber(N.long_) }], 
+     g_injectX12X_asNumberXN_byteX: [function({g}) { return g.inject(12).asNumber(N.byte_) }], 
+     g_injectX32768X_asNumberXN_shortX: [function({g}) { return g.inject(32768).asNumber(N.short_) }], 
+     g_injectX300X_asNumberXN_byteX: [function({g}) { return g.inject(300).asNumber(N.byte_) }], 
+     g_injectX5X_asNumber: [function({g}) { return g.inject("5").asNumber() }], 
+     g_injectX5X_asNumberXN_byteX: [function({g}) { return g.inject("5").asNumber(N.byte_) }], 
+     g_injectX1_000X_asNumberXN_bigIntX: [function({g}) { return g.inject("1,000").asNumber(N.bigInt) }], 
+     g_injectXtestX_asNumber: [function({g}) { return g.inject("test").asNumber() }], 
+     g_injectX_1_2_3_4X_asNumber: [function({g}) { return g.inject([1, 2, 3, 4]).asNumber() }], 
+     g_injectX1_2_3_4X_unfold_asNumber: [function({g}) { return g.inject([1, 2, 3, 4]).unfold().asNumber() }], 
+     g_injectX_1__2__3__4_X_asNumberXX_foldXX: [function({g}) { return g.inject("1", 2, "3", 4).asNumber().fold() }], 
+     g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX: [function({g}) { return g.inject(1.0, 2, 3, "4", "0x5").asNumber().sum().asNumber(N.byte_) }], 
+     g_injectXnullX_asNumberXN_intX: [function({g}) { return g.inject(null).asNumber(N.int_) }], 
+     g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX: [function({g}) { return g.V().as("a").out("knows").as("b").math("a + b").by("age").asNumber(N.int_) }], 
+     g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX: [function({g}) { return g.withSideEffect("x", 100).V().values("age").math("_ + x").asNumber(N.long_) }], 
 -    g_injectX1_2X_asString: [function({g}) { return g.inject(1, 2).asString() }], 
 -    g_injectX1_2X_asStringXlocalX: [function({g}) { return g.inject(1, 2).asString(Scope.local) }], 
 -    g_injectXlist_1_2X_asStringXlocalX: [function({g}) { return g.inject([1, 2]).asString(Scope.local) }], 
 -    g_injectX1_nullX_asString: [function({g}) { return g.inject(null, 1).asString() }], 
 -    g_injectX1_nullX_asStringXlocalX: [function({g}) { return g.inject([1, null]).asString(Scope.local) }], 
 +    g_injectX1_2X_asString: [function({g, xx1, xx2}) { return g.inject(xx1, xx2).asString() }], 
 +    g_injectX1_2X_asStringXlocalX: [function({g, xx1, xx2}) { return g.inject(xx1, xx2).asString(Scope.local) }], 
 +    g_injectXlist_1_2X_asStringXlocalX: [function({g, xx1}) { return g.inject(xx1).asString(Scope.local) }], 
 +    g_injectX1_nullX_asString: [function({g, xx1}) { return g.inject(null, xx1).asString() }], 
 +    g_injectX1_nullX_asStringXlocalX: [function({g, xx1}) { return g.inject(xx1).asString(Scope.local) }], 
      g_V_valueMapXnameX_asString: [function({g}) { return g.V().valueMap("name").asString() }], 
      g_V_valueMapXnameX_order_fold_asStringXlocalX: [function({g}) { return g.V().valueMap("name").order().fold().asString(Scope.local) }], 
      g_V_asString: [function({g}) { return g.V().asString() }], 
diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js
index 3fa26b3065,d723c85cd9..4cac41b83e
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js
@@@ -157,40 -158,43 +157,43 @@@ describe('GraphBinary.AnySerializer', (
        },
  
        // EnumSerializer (actually represents different enum like types)
 -      { v: new t.EnumValue('Barrier', 'normSack'),
 +      { v: new EnumValue('Barrier', 'normSack'),
          b: [ DataType.BARRIER,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x08, ...from('normSack') ]
        },
 -      { v: new t.EnumValue('Cardinality', 'single'),
 +      { v: new EnumValue('Cardinality', 'single'),
          b: [ DataType.CARDINALITY,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x06, ...from('single') ]
        },
 -      { v: new t.EnumValue('Column', 'keys'),
 +      { v: new EnumValue('Column', 'keys'),
          b: [ DataType.COLUMN,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x04, ...from('keys') ]
        },
 -      { v: new t.EnumValue('Direction', 'OUT'),
 +      { v: new EnumValue('Direction', 'OUT'),
          b: [ DataType.DIRECTION,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x03, ...from('OUT') ]
        },
 -      { v: new t.EnumValue('DT', 'minute'),
 +      { v: new EnumValue('DT', 'minute'),
          b: [ DataType.DT,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x06, ...from('minute') ]
        },
 -      { v: new t.EnumValue('Merge', 'onMatch'),
 +      { v: new EnumValue('Merge', 'onMatch'),
          b: [ DataType.MERGE,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x07, ...from('onMatch') ]
        },
-       { v: new EnumValue('Operator', 'addAll'),
+       { v: new t.EnumValue('N', 'byte'),
+         b: [ DataType.N,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x04, ...from('byte') ]
+       },
+       { v: new t.EnumValue('Operator', 'addAll'),
          b: [ DataType.OPERATOR,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x06, ...from('addAll') ]
        },
 -      { v: new t.EnumValue('Order', 'desc'),
 +      { v: new EnumValue('Order', 'desc'),
          b: [ DataType.ORDER,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x04, ...from('desc') ]
        },
 -      { v: new t.EnumValue('Pick', 'any'),
 +      { v: new EnumValue('Pick', 'any'),
          b: [ DataType.PICK,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x03, ...from('any') ]
        },
 -      { v: new t.EnumValue('Pop', 'first'),
 +      { v: new EnumValue('Pop', 'first'),
          b: [ DataType.POP,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x05, ...from('first') ]
        },
 -      { v: new t.EnumValue('Scope', 'local'),
 +      { v: new EnumValue('Scope', 'local'),
          b: [ DataType.SCOPE,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x05, ...from('local') ]
        },
 -      { v: new t.EnumValue('T', 'id'),
 +      { v: new EnumValue('T', 'id'),
          b: [ DataType.T,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x02, ...from('id') ]
        },
  
@@@ -514,11 -518,15 +517,15 @@@
  
        // MERGE
        { v:null,                                   b:[0x2e,0x01] },
 -      { v:new t.EnumValue('Merge','onCreate'),    b:[0x2e,0x00, 0x03,0x00, 0x00,0x00,0x00,0x08, ...from('onCreate')] },
 +      { v:new EnumValue('Merge','onCreate'),    b:[0x2e,0x00, 0x03,0x00, 0x00,0x00,0x00,0x08, ...from('onCreate')] },
  
+       // N
+       { v:null,                                   b:[0x30,0x01] },
+       { v:new t.EnumValue('N','byte'),         b:[0x30,0x00, 0x03,0x00, 0x00,0x00,0x00,0x04, ...from('byte')] },
+ 
        // OPERATOR
        { v:null,                                   b:[0x19,0x01] },
 -      { v:new t.EnumValue('Operator','addAll'),   b:[0x19,0x00, 0x03,0x00, 0x00,0x00,0x00,0x06, ...from('addAll')] },
 +      { v:new EnumValue('Operator','addAll'),   b:[0x19,0x00, 0x03,0x00, 0x00,0x00,0x00,0x06, ...from('addAll')] },
  
        // ORDER
        { v:null,                                   b:[0x1A,0x01] },
diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/EnumSerializer-test.js
index 1fec94c20f,4dc0abd616..76f61d47d9
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/EnumSerializer-test.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/EnumSerializer-test.js
@@@ -20,27 -20,29 +20,28 @@@
  /**
   * @author Igor Ostapenko
   */
 -'use strict';
  
 -const utils = require('./utils');
 -const assert = require('assert');
 -const { enumSerializer } = require('../../../lib/structure/io/binary/GraphBinary');
 -const t = require('../../../lib/process/traversal');
 +import { ser_title, des_title, cbuf_title } from './utils.js';
 +import assert from 'assert';
 +import { enumSerializer } from '../../../lib/structure/io/binary/GraphBinary.js';
- import { barrier, cardinality, column, direction, operator, order, pick, pop, scope, t, EnumValue } from '../../../lib/process/traversal.js';
++import { barrier, cardinality, column, direction, operator, order, pick, pop, scope, t, n, EnumValue } from '../../../lib/process/traversal.js';
  
  const { from, concat } = Buffer;
  
  describe('GraphBinary.EnumSerializer', () => {
  
    const types = [
 -    { name: 'Barrier',     code: from([0x13]), enum: t.barrier },
 -    { name: 'Cardinality', code: from([0x16]), enum: t.cardinality },
 -    { name: 'Column',      code: from([0x17]), enum: t.column },
 -    { name: 'Direction',   code: from([0x18]), enum: t.direction },
 -    { name: 'N',           code: from([0x30]), enum: t.n },
 -    { name: 'Operator',    code: from([0x19]), enum: t.operator },
 -    { name: 'Order',       code: from([0x1A]), enum: t.order },
 -    { name: 'Pick',        code: from([0x1B]), enum: t.pick },
 -    { name: 'Pop',         code: from([0x1C]), enum: t.pop },
 -    { name: 'Scope',       code: from([0x1F]), enum: t.scope },
 -    { name: 'T',           code: from([0x20]), enum: t.t },
 +    { name: 'Barrier',     code: from([0x13]), enum: barrier },
 +    { name: 'Cardinality', code: from([0x16]), enum: cardinality },
 +    { name: 'Column',      code: from([0x17]), enum: column },
 +    { name: 'Direction',   code: from([0x18]), enum: direction },
 +    { name: 'Operator',    code: from([0x19]), enum: operator },
 +    { name: 'Order',       code: from([0x1A]), enum: order },
 +    { name: 'Pick',        code: from([0x1B]), enum: pick },
 +    { name: 'Pop',         code: from([0x1C]), enum: pop },
 +    { name: 'Scope',       code: from([0x1F]), enum: scope },
 +    { name: 'T',           code: from([0x20]), enum: t },
++    { name: 'N',           code: from([0x30]), enum: n },
    ];
    const value_flag = from([0x00]);
  
diff --cc gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
index 0b64e65ee7,887a9191d7..1285919bdd
--- a/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
+++ b/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
@@@ -320,11 -319,15 +320,15 @@@ class GraphTraversal(Traversal)
          return self
  
      def as_date(self, *args):
 -        self.bytecode.add_step("asDate", *args)
 +        self.gremlin_lang.add_step("asDate", *args)
          return self
  
+     def as_number(self, *args):
 -        self.bytecode.add_step("asNumber", *args)
++        self.gremlin_lang.add_step("asNumber", *args)
+         return self
+ 
      def as_string(self, *args):
 -        self.bytecode.add_step("asString", *args)
 +        self.gremlin_lang.add_step("asString", *args)
          return self
  
      def barrier(self, *args):
@@@ -1106,11 -1113,15 +1110,15 @@@ class __(object, metaclass=MagicType)
  
      @classmethod
      def as_date(cls, *args):
 -        return cls.graph_traversal(None, None, Bytecode()).as_date(*args)
 +        return cls.graph_traversal(None, None, GremlinLang()).as_date(*args)
  
+     @classmethod
+     def as_number(cls, *args):
 -        return cls.graph_traversal(None, None, Bytecode()).as_number(*args)
++        return cls.graph_traversal(None, None, GremlinLang()).as_number(*args)
+ 
      @classmethod
      def as_string(cls, *args):
 -        return cls.graph_traversal(None, None, Bytecode()).as_string(*args)
 +        return cls.graph_traversal(None, None, GremlinLang()).as_string(*args)
  
      @classmethod
      def barrier(cls, *args):
diff --cc gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py
index 7e7eeb81bd,fa1e69352f..dda7c0845d
--- a/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py
+++ b/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py
@@@ -16,22 -16,29 +16,22 @@@ KIND, either express or implied.  See t
  specific language governing permissions and limitations
  under the License.
  """
 -
 -import datetime
  import calendar
 -import uuid
 -import math
  import io
 +import logging
 +import math
  import struct
 +import uuid
  from collections import OrderedDict
 -import logging
 -
 +from datetime import datetime, timedelta, timezone
  from struct import pack, unpack
 +
  from aenum import Enum
- from gremlin_python.process.traversal import Direction, T, Merge
 -from datetime import timedelta
 -from gremlin_python import statics
 -from gremlin_python.statics import FloatType, BigDecimal, FunctionType, ShortType, IntType, LongType, BigIntType, \
 -                                   TypeType, DictType, ListType, SetType, SingleByte, ByteBufferType, GremlinType, \
 -                                   SingleChar
 -from gremlin_python.process.traversal import Barrier, Binding, Bytecode, Cardinality, Column, Direction, DT, Merge, N, \
 -                                             Operator, Order, Pick, Pop, P, Scope, TextP, Traversal, Traverser, \
 -                                             TraversalStrategy, T
 -from gremlin_python.process.graph_traversal import GraphTraversal
++from gremlin_python.process.traversal import Direction, T, Merge, N
 +from gremlin_python.statics import FloatType, BigDecimal, ShortType, IntType, LongType, BigIntType, \
 +    DictType, SetType, SingleByte, SingleChar
  from gremlin_python.structure.graph import Graph, Edge, Property, Vertex, VertexProperty, Path
 -from gremlin_python.structure.io.util import HashableDict, SymbolUtil
 +from gremlin_python.structure.io.util import HashableDict, SymbolUtil, Marker
  
  log = logging.getLogger(__name__)
  
@@@ -66,13 -87,33 +66,14 @@@ class DataType(Enum)
      bigdecimal = 0x22
      biginteger = 0x23
      byte = 0x24
 -    bytebuffer = 0x25
 +    binary = 0x25
      short = 0x26
      boolean = 0x27
 -    textp = 0x28
 -    traversalstrategy = 0x29
 -    bulkset = 0x2a
      tree = 0x2b                   # not supported - no tree object in Python yet
 -    metrics = 0x2c
 -    traversalmetrics = 0x2d
 -    merge = 0x2e
 -    dt = 0x2f
+     n = 0x30
      char = 0x80
      duration = 0x81
 -    inetaddress = 0x82            # todo
 -    instant = 0x83                # todo
 -    localdate = 0x84              # todo
 -    localdatetime = 0x85          # todo
 -    localtime = 0x86              # todo
 -    monthday = 0x87               # todo
 -    offsetdatetime = 0x88
 -    offsettime = 0x89             # todo
 -    period = 0x8a                 # todo
 -    year = 0x8b                   # todo
 -    yearmonth = 0x8c              # todo
 -    zonedatetime = 0x8d           # todo
 -    zoneoffset = 0x8e             # todo
 +    marker = 0xfd
      custom = 0x00                 # todo
  
  
@@@ -746,6 -978,43 +747,11 @@@ class MergeIO(_EnumIO)
      python_type = Merge
  
  
+ class NIO(_EnumIO):
+     graphbinary_type = DataType.n
+     python_type = N
+ 
+ 
 -class ScopeIO(_EnumIO):
 -    graphbinary_type = DataType.scope
 -    python_type = Scope
 -
 -
 -class TIO(_EnumIO):
 -    graphbinary_type = DataType.t
 -    python_type = T
 -
 -
 -class TraverserIO(_GraphBinaryTypeIO):
 -    graphbinary_type = DataType.traverser
 -    python_type = Traverser
 -
 -    @classmethod
 -    def dictify(cls, obj, writer, to_extend, as_value=False, nullable=True):
 -        cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
 -        to_extend.extend(int64_pack(obj.bulk))
 -        writer.to_dict(obj.object, to_extend)
 -        return to_extend
 -
 -    @classmethod
 -    def objectify(cls, buff, reader, nullable=True):
 -        return cls.is_null(buff, reader, cls._read_traverser, nullable)
 -
 -    @classmethod
 -    def _read_traverser(cls, b, r):
 -        bulk = int64_unpack(b.read(8))
 -        obj = r.read_object(b)
 -        return Traverser(obj, bulk=bulk)
 -
 -
  class ByteIO(_GraphBinaryTypeIO):
      python_type = SingleByte
      graphbinary_type = DataType.byte
diff --cc gremlin-python/src/main/python/radish/gremlin.py
index e49ed1f85d,f5e2755fd9..21866847ba
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@@ -693,16 -691,40 +693,40 @@@ world.gremlins = 
      'g_injectXstrX_asDate': [(lambda g:g.inject('2023-08-02T00:00:00Z').as_date())], 
      'g_injectXstr_offsetX_asDate': [(lambda g:g.inject('2023-08-02T00:00:00-07:00').as_date())], 
      'g_injectX1694017707000X_asDate': [(lambda g:g.inject(long(1694017707000)).as_date())], 
 -    'g_injectX1694017708000LX_asDate': [(lambda g:g.inject(long(1694017708000)).as_date())], 
 -    'g_injectX1694017709000dX_asDate': [(lambda g:g.inject(1694017709000.1).as_date())], 
 -    'g_injectX1_2X_asDate': [(lambda g:g.inject([1, 2]).as_date())], 
 +    'g_injectX1694017708000LX_asDate': [(lambda g, xx1=None:g.inject(xx1).as_date())], 
 +    'g_injectX1694017709000dX_asDate': [(lambda g, xx1=None:g.inject(xx1).as_date())], 
 +    'g_injectX1_2X_asDate': [(lambda g, xx1=None:g.inject(xx1).as_date())], 
      'g_injectXnullX_asDate': [(lambda g:g.inject(None).as_date())], 
      'g_injectXinvalidstrX_asDate': [(lambda g:g.inject('This String is not an ISO 8601 Date').as_date())], 
+     'g_injectX5bX_asNumber': [(lambda g:g.inject(5).as_number())], 
+     'g_injectX5sX_asNumber': [(lambda g:g.inject(5).as_number())], 
+     'g_injectX5iX_asNumber': [(lambda g:g.inject(5).as_number())], 
+     'g_injectX5lX_asNumber': [(lambda g:g.inject(long(5)).as_number())], 
+     'g_injectX5nX_asNumber': [(lambda g:g.inject(bigint(5)).as_number())], 
+     'g_injectX5_0X_asNumber': [(lambda g:g.inject(5.0).as_number())], 
+     'g_injectX5_75fX_asNumber': [(lambda g:g.inject(5.75).as_number())], 
+     'g_injectX5_43X_asNumberXN_intX': [(lambda g:g.inject(5.43).as_number(N.int))], 
+     'g_injectX5_67X_asNumberXN_intX': [(lambda g:g.inject(5.67).as_number(N.int))], 
+     'g_injectX5X_asNumberXN_longX': [(lambda g:g.inject(5).as_number(N.long))], 
+     'g_injectX12X_asNumberXN_byteX': [(lambda g:g.inject(12).as_number(N.byte))], 
+     'g_injectX32768X_asNumberXN_shortX': [(lambda g:g.inject(32768).as_number(N.short))], 
+     'g_injectX300X_asNumberXN_byteX': [(lambda g:g.inject(300).as_number(N.byte))], 
+     'g_injectX5X_asNumber': [(lambda g:g.inject('5').as_number())], 
+     'g_injectX5X_asNumberXN_byteX': [(lambda g:g.inject('5').as_number(N.byte))], 
+     'g_injectX1_000X_asNumberXN_bigIntX': [(lambda g:g.inject('1,000').as_number(N.big_int))], 
+     'g_injectXtestX_asNumber': [(lambda g:g.inject('test').as_number())], 
+     'g_injectX_1_2_3_4X_asNumber': [(lambda g:g.inject([1, 2, 3, 4]).as_number())], 
+     'g_injectX1_2_3_4X_unfold_asNumber': [(lambda g:g.inject([1, 2, 3, 4]).unfold().as_number())], 
+     'g_injectX_1__2__3__4_X_asNumberXX_foldXX': [(lambda g:g.inject('1', 2, '3', 4).as_number().fold())], 
+     'g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX': [(lambda g:g.inject(1.0, 2, 3, '4', '0x5').as_number().sum_().as_number(N.byte))], 
+     'g_injectXnullX_asNumberXN_intX': [(lambda g:g.inject(None).as_number(N.int))], 
+     'g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX': [(lambda g:g.V().as_('a').out('knows').as_('b').math('a + b').by('age').as_number(N.int))], 
+     'g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX': [(lambda g:g.with_side_effect('x', 100).V().values('age').math('_ + x').as_number(N.long))], 
 -    'g_injectX1_2X_asString': [(lambda g:g.inject(1, 2).as_string())], 
 -    'g_injectX1_2X_asStringXlocalX': [(lambda g:g.inject(1, 2).as_string(Scope.local))], 
 -    'g_injectXlist_1_2X_asStringXlocalX': [(lambda g:g.inject([1, 2]).as_string(Scope.local))], 
 -    'g_injectX1_nullX_asString': [(lambda g:g.inject(None, 1).as_string())], 
 -    'g_injectX1_nullX_asStringXlocalX': [(lambda g:g.inject([1, None]).as_string(Scope.local))], 
 +    'g_injectX1_2X_asString': [(lambda g, xx1=None,xx2=None:g.inject(xx1, xx2).as_string())], 
 +    'g_injectX1_2X_asStringXlocalX': [(lambda g, xx1=None,xx2=None:g.inject(xx1, xx2).as_string(Scope.local))], 
 +    'g_injectXlist_1_2X_asStringXlocalX': [(lambda g, xx1=None:g.inject(xx1).as_string(Scope.local))], 
 +    'g_injectX1_nullX_asString': [(lambda g, xx1=None:g.inject(None, xx1).as_string())], 
 +    'g_injectX1_nullX_asStringXlocalX': [(lambda g, xx1=None:g.inject(xx1).as_string(Scope.local))], 
      'g_V_valueMapXnameX_asString': [(lambda g:g.V().value_map('name').as_string())], 
      'g_V_valueMapXnameX_order_fold_asStringXlocalX': [(lambda g:g.V().value_map('name').order().fold().as_string(Scope.local))], 
      'g_V_asString': [(lambda g:g.V().as_string())],