Modified: tinkerpop/site/docs/3.2.8-SNAPSHOT/reference/index.html
URL: 
http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.8-SNAPSHOT/reference/index.html?rev=1827535&r1=1827534&r2=1827535&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.8-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.8-SNAPSHOT/reference/index.html Thu Mar 22 22:54:14 
2018
@@ -1134,6 +1134,7 @@ table.CodeRay td.code>pre{padding:0}
 <li><a href="#_static_enums_and_methods_2">Static Enums and Methods</a></li>
 <li><a href="#_bindings_2">Bindings</a></li>
 <li><a href="#_traversal_strategies_2">Traversal Strategies</a></li>
+<li><a href="#_the_lambda_solution_3">The Lambda Solution</a></li>
 </ul>
 </li>
 <li><a href="#gremlin-javascript">Gremlin-JavaScript</a>
@@ -2028,37 +2029,36 @@ gremlin&gt; graph.features()
 ==&gt;FEATURES
 &gt; GraphFeatures
 &gt;-- <span class="key">Transactions</span>: <span 
class="predefined-constant">false</span>
-&gt;-- <span class="key">ThreadedTransactions</span>: <span 
class="predefined-constant">false</span>
-&gt;-- <span class="key">Computer</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">Persistence</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">ConcurrentAccess</span>: <span 
class="predefined-constant">false</span>
+&gt;-- <span class="key">ThreadedTransactions</span>: <span 
class="predefined-constant">false</span>
+&gt;-- <span class="key">Computer</span>: <span 
class="predefined-constant">true</span>
 &gt; VariableFeatures
 &gt;-- <span class="key">Variables</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">BooleanValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">ByteValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">DoubleValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">FloatValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">IntegerValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">LongValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MapValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MixedListValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">SerializableValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">UniformListValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">BooleanArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">ByteArrayValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">DoubleArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">FloatArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">LongArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringArrayValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">BooleanValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">ByteValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">DoubleValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">FloatValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">IntegerValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">LongValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">MapValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">MixedListValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">DoubleArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt; VertexFeatures
-&gt;-- <span class="key">AddVertices</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">MetaProperties</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">MultiProperties</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">AddVertices</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveVertices</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">DuplicateMultiProperties</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">AddProperty</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MultiProperties</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveProperty</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringIds</span>: <span 
class="predefined-constant">true</span>
@@ -2066,8 +2066,8 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">CustomIds</span>: <span 
class="predefined-constant">false</span>
 &gt;-- <span class="key">AnyIds</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">UserSuppliedIds</span>: <span 
class="predefined-constant">true</span>
-&gt; VertexPropertyFeatures
 &gt;-- <span class="key">AddProperty</span>: <span 
class="predefined-constant">true</span>
+&gt; VertexPropertyFeatures
 &gt;-- <span class="key">RemoveProperty</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringIds</span>: <span 
class="predefined-constant">true</span>
@@ -2075,29 +2075,29 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">CustomIds</span>: <span 
class="predefined-constant">false</span>
 &gt;-- <span class="key">AnyIds</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">UserSuppliedIds</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">AddProperty</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="predefined-type">Properties</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">BooleanValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">ByteValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">DoubleValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">FloatValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">IntegerValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">LongValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MapValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MixedListValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">SerializableValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">UniformListValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">BooleanArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">ByteArrayValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">DoubleArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">FloatArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">LongArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringArrayValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">BooleanValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">ByteValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">DoubleValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">FloatValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">IntegerValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">LongValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">MapValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">MixedListValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">DoubleArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt; EdgeFeatures
 &gt;-- <span class="key">RemoveEdges</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">AddEdges</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">AddProperty</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveProperty</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringIds</span>: <span 
class="predefined-constant">true</span>
@@ -2105,26 +2105,27 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">CustomIds</span>: <span 
class="predefined-constant">false</span>
 &gt;-- <span class="key">AnyIds</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">UserSuppliedIds</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">AddProperty</span>: <span 
class="predefined-constant">true</span>
 &gt; EdgePropertyFeatures
 &gt;-- <span class="predefined-type">Properties</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">BooleanValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">ByteValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">DoubleValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">FloatValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">IntegerValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">LongValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MapValues</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MixedListValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">SerializableValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">UniformListValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">BooleanArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">ByteArrayValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">DoubleArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">FloatArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">LongArrayValues</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">StringArrayValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">BooleanValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">ByteValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">DoubleValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">FloatValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">IntegerValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">LongValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">MapValues</span>: <span 
class="predefined-constant">true</span>
-&gt;-- <span class="key">MixedListValues</span>: <span 
class="predefined-constant">true</span></code></pre>
+&gt;-- <span class="key">DoubleArrayValues</span>: <span 
class="predefined-constant">true</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2290,7 +2291,7 @@ gremlin&gt; g.V(v).values(<span class="s
 <p>Vertex property removal is identical to property removal.</p>
 </li>
 <li>
-<p>It is property to get the properties of a vertex property.</p>
+<p>Gets the meta-properties of each vertex property.</p>
 </li>
 <li>
 <p>A vertex property can have any number of key/value properties attached to 
it.</p>
@@ -3005,7 +3006,7 @@ gremlin&gt; g = graph.traversal()
 gremlin&gt; f = <span class="keyword">new</span> <span 
class="predefined-type">ByteArrayOutputStream</span>()
 ==&gt;
 gremlin&gt; mapper = graph.io(graphson()).mapper().embedTypes(<span 
class="predefined-constant">true</span>).create()
-==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span 
class="error">@</span><span class="integer">48</span>a46b0f
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span 
class="annotation">@d504137</span>
 gremlin&gt; 
graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span 
class="integer">1</span>).next(), BOTH)
 gremlin&gt; f.close()</code></pre>
 </div>
@@ -3195,7 +3196,7 @@ gremlin&gt; g = graph.traversal()
 gremlin&gt; f = <span class="keyword">new</span> <span 
class="predefined-type">ByteArrayOutputStream</span>()
 ==&gt;
 gremlin&gt; mapper = 
graph.io(graphson()).mapper().version(GraphSONVersion.V2_0).create()
-==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span 
class="annotation">@ac4e690</span>
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span 
class="error">@</span><span class="float">32d</span><span 
class="float">0d</span><span class="integer">7</span>eb
 gremlin&gt; 
graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span 
class="integer">1</span>).next(), BOTH)
 gremlin&gt; f.close()</code></pre>
 </div>
@@ -3832,7 +3833,8 @@ gremlin&gt; g.V().out(<span class="strin
 ==&gt;v[<span class="integer">3</span>]
 ==&gt;v[<span class="integer">5</span>]
 ==&gt;v[<span class="integer">3</span>]
-==&gt;v[<span class="integer">3</span>]</code></pre>
+==&gt;v[<span class="integer">3</span>]
+gremlin&gt; g.addV(<span class="string"><span class="delimiter">'</span><span 
class="content">person</span><span class="delimiter">'</span></span>).iterate() 
<span class="comment">//</span> <b class="conum">(9)</b></code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -3861,6 +3863,11 @@ gremlin&gt; g.V().out(<span class="strin
 <li>
 <p><code>fill(collection)</code> will put all results in the provided 
collection and return the collection when complete.</p>
 </li>
+<li>
+<p><code>iterate()</code> does not exactly fit the definition of a terminal 
step in that it doesn&#8217;t return a result, but still
+returns a traversal - it does however behave as a terminal step in that it 
iterates the traversal and generates side
+effects without returning the actual result.</p>
+</li>
 </ol>
 </div>
 <div class="paragraph">
@@ -4017,8 +4024,8 @@ gremlin&gt; g.V(<span class="integer">1<
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#property-java.lang.Object-java.lang.Object-java.lang.Object&#8230;&#8203;-";><code>property(Object,
 Object, Object&#8230;&#8203;)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#property-org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality-java.lang.Object-java.lang.Object-java.lang.Object&#8230;&#8203;-";><code>property(Cardinality,
 Object, Object, Object&#8230;&#8203;)</code></a>,
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#property-java.lang.Object-java.lang.Object-java.lang.Object...-";><code>property(Object,
 Object, Object&#8230;&#8203;)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#property-org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality-java.lang.Object-java.lang.Object-java.lang.Object...-";><code>property(Cardinality,
 Object, Object, Object&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html";><code>Cardinality</code></a></p>
 </div>
 </div>
@@ -4133,7 +4140,7 @@ only two traversals can be and&#8217;d t
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#and-org.apache.tinkerpop.gremlin.process.traversal.Traversal&#8230;&#8203;-";><code>and(Traversal&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#and-org.apache.tinkerpop.gremlin.process.traversal.Traversal...-";><code>and(Traversal&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -4185,7 +4192,7 @@ gremlin&gt; g.V().as(<span class="string
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#as-java.lang.String-java.lang.String&#8230;&#8203;-";><code>as(String,String&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#as-java.lang.String-java.lang.String...-";><code>as(String,String&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -4248,13 +4255,13 @@ gremlin&gt; graph.io(graphml()).readGrap
 gremlin&gt; g = graph.traversal().withoutStrategies(LazyBarrierStrategy) <span 
class="invisible">//</span><b class="conum">1</b><span 
class="invisible">\</span>
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">808</span> <span class="key">edges</span>:<span 
class="integer">8049</span>], standard]
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().both().both().both().count().next()} <span 
class="invisible">//</span><b class="conum">2</b><span 
class="invisible">\</span>
-==&gt;<span class="float">8500.939267</span>
+==&gt;<span class="float">9868.297112</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().repeat(both()).times(<span 
class="integer">3</span>).count().next()} <span class="invisible">//</span><b 
class="conum">3</b><span class="invisible">\</span>
-==&gt;<span class="float">37.353570999999995</span>
+==&gt;<span class="float">24.343391999999998</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().both().barrier().both().barrier().both().barrier().count().next()}
 <span class="invisible">//</span><b class="conum">4</b><span 
class="invisible">\</span>
-==&gt;<span class="float">15.627635</span>
+==&gt;<span class="float">13.407573999999999</span>
 ==&gt;<span class="integer">126653966</span></code></pre>
 </div>
 </div>
@@ -4291,7 +4298,7 @@ gremlin&gt; graph.io(graphml()).readGrap
 gremlin&gt; g = graph.traversal() <span class="invisible">//</span><b 
class="conum">1</b><span class="invisible">\</span>
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">808</span> <span class="key">edges</span>:<span 
class="integer">8049</span>], standard]
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().both().both().both().count().next()}
-==&gt;<span class="float">14.286857</span>
+==&gt;<span class="float">14.341612</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; g.V().both().both().both().count().iterate().toString() <span 
class="invisible">//</span><b class="conum">2</b><span 
class="invisible">\</span>
 ==&gt;[TinkerGraphStep(vertex,<span class="type">[]</span>), 
VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">2500</span>), 
VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">2500</span>), 
VertexStep(BOTH,edge), CountGlobalStep]</code></pre>
@@ -4443,7 +4450,7 @@ gremlin&gt; g.V().groupCount(<span class
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#cap-java.lang.String-java.lang.String&#8230;&#8203;-";><code>cap(String,String&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#cap-java.lang.String-java.lang.String...-";><code>cap(String,String&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -4587,7 +4594,7 @@ gremlin&gt; g.V().hasLabel(<span class="
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#coalesce-org.apache.tinkerpop.gremlin.process.traversal.Traversal&#8230;&#8203;-";><code>coalesce(Traversal&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#coalesce-org.apache.tinkerpop.gremlin.process.traversal.Traversal...-";><code>coalesce(Traversal&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -4599,7 +4606,6 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="content">
 <pre class="CodeRay highlight"><code data-lang="groovy">gremlin&gt; 
g.V().coin(<span class="float">0.5</span>)
 ==&gt;v[<span class="integer">2</span>]
-==&gt;v[<span class="integer">6</span>]
 gremlin&gt; g.V().coin(<span class="float">0.0</span>)
 gremlin&gt; g.V().coin(<span class="float">1.0</span>)
 ==&gt;v[<span class="integer">1</span>]
@@ -4799,12 +4805,12 @@ has been seen or not.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code data-lang="groovy">gremlin&gt; 
g.V().valueMap(<span class="predefined-constant">true</span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span 
class="key">name</span>:[marko],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">2</span>,<span 
class="key">name</span>:[vadas],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">3</span>,<span 
class="key">name</span>:[lop],<span class="key">label</span>:software]
-==&gt;[<span class="key">id</span>:<span class="integer">4</span>,<span 
class="key">name</span>:[josh],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">5</span>,<span 
class="key">name</span>:[ripple],<span class="key">label</span>:software]
-==&gt;[<span class="key">id</span>:<span class="integer">6</span>,<span 
class="key">name</span>:[peter],<span class="key">label</span>:person]
+==&gt;[<span class="key">name</span>:[marko],<span class="key">id</span>:<span 
class="integer">1</span>,<span class="key">label</span>:person]
+==&gt;[<span class="key">name</span>:[vadas],<span class="key">id</span>:<span 
class="integer">2</span>,<span class="key">label</span>:person]
+==&gt;[<span class="key">name</span>:[lop],<span class="key">id</span>:<span 
class="integer">3</span>,<span class="key">label</span>:software]
+==&gt;[<span class="key">name</span>:[josh],<span class="key">id</span>:<span 
class="integer">4</span>,<span class="key">label</span>:person]
+==&gt;[<span class="key">name</span>:[ripple],<span 
class="key">id</span>:<span class="integer">5</span>,<span 
class="key">label</span>:software]
+==&gt;[<span class="key">name</span>:[peter],<span class="key">id</span>:<span 
class="integer">6</span>,<span class="key">label</span>:person]
 gremlin&gt; g.V().dedup().by(label).values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)
 ==&gt;marko
 ==&gt;lop</code></pre>
@@ -4845,8 +4851,8 @@ gremlin&gt; g.V().as(<span class="string
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#dedup-org.apache.tinkerpop.gremlin.process.traversal.Scope-java.lang.String&#8230;&#8203;-";><code>dedup(Scope,String&#8230;&#8203;)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#dedup-java.lang.String&#8230;&#8203;-";><code>dedup(String&#8230;&#8203;)</code></a>,
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#dedup-org.apache.tinkerpop.gremlin.process.traversal.Scope-java.lang.String...-";><code>dedup(Scope,String&#8230;&#8203;)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#dedup-java.lang.String...-";><code>dedup(String&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Scope.html";><code>Scope</code></a></p>
 </div>
 </div>
@@ -4916,14 +4922,14 @@ post strategy application. The final tra
 Original Traversal                 [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 
 ConnectiveStrategy           [D]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
-MatchPredicateStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
-FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
-InlineFilterStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
-AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
+MatchPredicateStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 PathRetractionStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
+FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
+InlineFilterStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
+AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
 LazyBarrierStrategy          [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
 TinkerGraphCountStrategy     [P]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
 TinkerGraphStepStrategy      [P]   
[TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
@@ -5065,7 +5071,7 @@ gremlin&gt; g.V().has(<span class="strin
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#V-java.lang.Object&#8230;&#8203;-";><code>V(Object&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#V-java.lang.Object...-";><code>V(Object&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -5311,14 +5317,14 @@ may provide a partial match extension.</
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#has-org.apache.tinkerpop.gremlin.structure.T-java.lang.Object-";><code>has(T,Object)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#has-org.apache.tinkerpop.gremlin.structure.T-org.apache.tinkerpop.gremlin.process.traversal.P-";><code>has(T,P)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#has-org.apache.tinkerpop.gremlin.structure.T-org.apache.tinkerpop.gremlin.process.traversal.Traversal-";><code>has(T,Traversal)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasId-java.lang.Object-java.lang.Object&#8230;&#8203;-";><code>hasId(Object,Object&#8230;&#8203;)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasId-java.lang.Object-java.lang.Object...-";><code>hasId(Object,Object&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasId-org.apache.tinkerpop.gremlin.process.traversal.P-";><code>hasId(P)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasKey-org.apache.tinkerpop.gremlin.process.traversal.P-";><code>hasKey(P)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasKey-java.lang.String-java.lang.String&#8230;&#8203;-";><code>hasKey(String,String&#8230;&#8203;)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasKey-java.lang.String-java.lang.String...-";><code>hasKey(String,String&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasLabel-org.apache.tinkerpop.gremlin.process.traversal.P-";><code>hasLabel(P)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasLabel-java.lang.String-java.lang.String&#8230;&#8203;-";><code>hasLabel(String,String&#8230;&#8203;)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasLabel-java.lang.String-java.lang.String...-";><code>hasLabel(String,String&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasNot-java.lang.String-";><code>hasNot(String)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasValue-java.lang.Object-java.lang.Object&#8230;&#8203;-";><code>hasValue(Object,Object&#8230;&#8203;)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasValue-java.lang.Object-java.lang.Object...-";><code>hasValue(Object,Object&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#hasValue-org.apache.tinkerpop.gremlin.process.traversal.P-";><code>hasValue(P)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/P.html";><code>P</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/structure/T.html";><code>T</code></a></p>
@@ -5429,7 +5435,7 @@ gremlin&gt; inject(<span class="integer"
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#inject-E&#8230;&#8203;-";><code>inject(Object)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#inject-E...-";><code>inject(Object)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -6068,7 +6074,7 @@ path of the traverser in <code>match()</
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#match-org.apache.tinkerpop.gremlin.process.traversal.Traversal&#8230;&#8203;-";><code>match(Traversal&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#match-org.apache.tinkerpop.gremlin.process.traversal.Traversal...-";><code>match(Traversal&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 </div>
@@ -6196,8 +6202,8 @@ not return any objects.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code data-lang="groovy">gremlin&gt; 
g.V().not(hasLabel(<span class="string"><span class="delimiter">'</span><span 
class="content">person</span><span 
class="delimiter">'</span></span>)).valueMap(<span 
class="predefined-constant">true</span>)
-==&gt;[<span class="key">id</span>:<span class="integer">3</span>,<span 
class="key">name</span>:[lop],<span class="key">lang</span>:[java],<span 
class="key">label</span>:software]
-==&gt;[<span class="key">id</span>:<span class="integer">5</span>,<span 
class="key">name</span>:[ripple],<span class="key">lang</span>:[java],<span 
class="key">label</span>:software]
+==&gt;[<span class="key">name</span>:[lop],<span 
class="key">lang</span>:[java],<span class="key">id</span>:<span 
class="integer">3</span>,<span class="key">label</span>:software]
+==&gt;[<span class="key">name</span>:[ripple],<span 
class="key">lang</span>:[java],<span class="key">id</span>:<span 
class="integer">5</span>,<span class="key">label</span>:software]
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).
            not(out(<span class="string"><span class="delimiter">'</span><span 
class="content">created</span><span 
class="delimiter">'</span></span>).count().is(gt(<span 
class="integer">1</span>))).values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>) <span class="invisible">//</span><b 
class="conum">1</b><span class="invisible">\</span>
 ==&gt;marko
@@ -6322,7 +6328,7 @@ only two traversals can be or&#8217;d to
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#or-org.apache.tinkerpop.gremlin.process.traversal.Traversal&#8230;&#8203;-";><code>or(Traversal&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#or-org.apache.tinkerpop.gremlin.process.traversal.Traversal...-";><code>or(Traversal&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -6410,15 +6416,15 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code data-lang="groovy">gremlin&gt; 
g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span 
class="content">person</span><span 
class="delimiter">'</span></span>).order().by(shuffle)
-==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">4</span>]
 ==&gt;v[<span class="integer">6</span>]
+==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">2</span>]
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).order().by(shuffle)
 ==&gt;v[<span class="integer">2</span>]
 ==&gt;v[<span class="integer">4</span>]
-==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">6</span>]</code></pre>
+==&gt;v[<span class="integer">6</span>]
+==&gt;v[<span class="integer">1</span>]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6499,12 +6505,12 @@ The <code>pageRank()</code>-step is a <c
 <pre class="CodeRay highlight"><code data-lang="groovy">gremlin&gt; g = 
graph.traversal().withComputer()
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">6</span> <span class="key">edges</span>:<span 
class="integer">6</span>], graphcomputer]
 gremlin&gt; g.V().pageRank().by(<span class="string"><span 
class="delimiter">'</span><span class="content">pageRank</span><span 
class="delimiter">'</span></span>).values(<span class="string"><span 
class="delimiter">'</span><span class="content">pageRank</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="float">0.4018125</span>
+==&gt;<span class="float">0.15000000000000002</span>
+==&gt;<span class="float">0.15000000000000002</span>
 ==&gt;<span class="float">0.19250000000000003</span>
 ==&gt;<span class="float">0.19250000000000003</span>
 ==&gt;<span class="float">0.23181250000000003</span>
-==&gt;<span class="float">0.15000000000000002</span>
-==&gt;<span class="float">0.15000000000000002</span>
+==&gt;<span class="float">0.4018125</span>
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).
            pageRank().
              by(outE(<span class="string"><span 
class="delimiter">'</span><span class="content">knows</span><span 
class="delimiter">'</span></span>)).
@@ -6512,8 +6518,8 @@ gremlin&gt; g.V().hasLabel(<span class="
            order().by(<span class="string"><span 
class="delimiter">'</span><span class="content">friendRank</span><span 
class="delimiter">'</span></span>,decr).valueMap(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>,<span class="string"><span 
class="delimiter">'</span><span class="content">friendRank</span><span 
class="delimiter">'</span></span>)
 ==&gt;[<span class="key">friendRank</span>:[<span 
class="float">0.21375000000000002</span>],<span class="key">name</span>:[vadas]]
 ==&gt;[<span class="key">friendRank</span>:[<span 
class="float">0.21375000000000002</span>],<span class="key">name</span>:[josh]]
-==&gt;[<span class="key">friendRank</span>:[<span 
class="float">0.15000000000000002</span>],<span class="key">name</span>:[peter]]
-==&gt;[<span class="key">friendRank</span>:[<span 
class="float">0.15000000000000002</span>],<span 
class="key">name</span>:[marko]]</code></pre>
+==&gt;[<span class="key">friendRank</span>:[<span 
class="float">0.15000000000000002</span>],<span class="key">name</span>:[marko]]
+==&gt;[<span class="key">friendRank</span>:[<span 
class="float">0.15000000000000002</span>],<span 
class="key">name</span>:[peter]]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6529,53 +6535,53 @@ gremlin&gt; g.V().hasLabel(<span class="
              by(<span class="string"><span class="delimiter">'</span><span 
class="content">friendRank</span><span class="delimiter">'</span></span>).
            order().by(<span class="string"><span 
class="delimiter">'</span><span class="content">friendRank</span><span 
class="delimiter">'</span></span>,decr).valueMap(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>,<span class="string"><span 
class="delimiter">'</span><span class="content">friendRank</span><span 
class="delimiter">'</span></span>).explain()
 ==&gt;Traversal Explanation
-=======================================================================================================================================================================================================================================
-Original Traversal                    [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), 
OrderGlobalStep([[value(friendRank), decr]]), Pro
-                                         pertyMapStep([name, 
friendRank],value)]
-
-ConnectiveStrategy              [D]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), 
OrderGlobalStep([[value(friendRank), decr]]), Pro
-                                         pertyMapStep([name, 
friendRank],value)]
-VertexProgramStrategy           [D]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-MatchPredicateStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-FilterRankingStrategy           [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-PathProcessorStrategy           [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-InlineFilterStrategy            [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-IncidentToAdjacentStrategy      [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-AdjacentToIncidentStrategy      [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-RepeatUnrollStrategy            [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-PathRetractionStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-MessagePassingReductionStrategy [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-RangeByIsCountStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-LazyBarrierStrategy             [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-OrderLimitStrategy              [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-TinkerGraphCountStrategy        [P]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-TinkerGraphStepStrategy         [P]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-ProfileStrategy                 [F]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-ComputerFinalizationStrategy    [T]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-ComputerVerificationStrategy    [V]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-StandardVerificationStrategy    [V]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+=============================================================================================================================================================================================================================================
+Original Traversal                    [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), 
OrderGlobalStep([[value(friendRank), decr]]), PropertyM
+                                         apStep([name, friendRank],value)]
+
+ConnectiveStrategy              [D]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), 
OrderGlobalStep([[value(friendRank), decr]]), PropertyM
+                                         apStep([name, friendRank],value)]
+VertexProgramStrategy           [D]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+MatchPredicateStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+PathProcessorStrategy           [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+IncidentToAdjacentStrategy      [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+RepeatUnrollStrategy            [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+PathRetractionStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+OrderLimitStrategy              [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+FilterRankingStrategy           [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+RangeByIsCountStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+InlineFilterStrategy            [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+AdjacentToIncidentStrategy      [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+LazyBarrierStrategy             [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+MessagePassingReductionStrategy [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+TinkerGraphCountStrategy        [P]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+TinkerGraphStepStrategy         [P]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+ProfileStrategy                 [F]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+ComputerFinalizationStrategy    [T]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+ComputerVerificationStrategy    [V]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+StandardVerificationStrategy    [V]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 
-Final Traversal                       
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), T
-                                         
raversalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]</code></pre>
+Final Traversal                       
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), Travers
+                                         
alVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6775,19 +6781,19 @@ profile results, but durations are not e
 ==&gt;Traversal Metrics
 Step                                                               Count  
Traversers       <span class="predefined-type">Time</span> (ms)    % Dur
 
=============================================================================================================
-TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.109</span>    <span 
class="float">11.06</span>
-VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>           
<span class="float">0.130</span>    <span class="float">13.16</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                             
                     <span class="integer">4</span>           <span 
class="integer">2</span>           <span class="float">0.087</span>     <span 
class="float">8.84</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">10</span>           <span class="integer">4</span>           
<span class="float">0.043</span>     <span class="float">4.44</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                             
                    <span class="integer">10</span>           <span 
class="integer">3</span>           <span class="float">0.028</span>     <span 
class="float">2.91</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">24</span>           <span class="integer">7</span>           
<span class="float">0.031</span>     <span class="float">3.14</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                             
                    <span class="integer">24</span>           <span 
class="integer">5</span>           <span class="float">0.145</span>    <span 
class="float">14.74</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">58</span>          <span class="integer">11</span>           
<span class="float">0.045</span>     <span class="float">4.57</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                             
                    <span class="integer">58</span>           <span 
class="integer">6</span>           <span class="float">0.154</span>    <span 
class="float">15.64</span>
-HasStep([~label.eq(person)])                                          <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.041</span>     <span class="float">4.19</span>
-PropertiesStep([age],value)                                           <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.040</span>     <span class="float">4.14</span>
-SumGlobalStep                                                          <span 
class="integer">1</span>           <span class="integer">1</span>           
<span class="float">0.129</span>    <span class="float">13.15</span>
-                                            &gt;TOTAL                     -    
       -           <span class="float">0.988</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.120</span>    <span 
class="float">12.84</span>
+VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>           
<span class="float">0.167</span>    <span class="float">17.81</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                             
                     <span class="integer">4</span>           <span 
class="integer">2</span>           <span class="float">0.091</span>     <span 
class="float">9.75</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">10</span>           <span class="integer">4</span>           
<span class="float">0.060</span>     <span class="float">6.38</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                             
                    <span class="integer">10</span>           <span 
class="integer">3</span>           <span class="float">0.028</span>     <span 
class="float">3.07</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">24</span>           <span class="integer">7</span>           
<span class="float">0.034</span>     <span class="float">3.65</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                             
                    <span class="integer">24</span>           <span 
class="integer">5</span>           <span class="float">0.036</span>     <span 
class="float">3.87</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">58</span>          <span class="integer">11</span>           
<span class="float">0.056</span>     <span class="float">5.96</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                             
                    <span class="integer">58</span>           <span 
class="integer">6</span>           <span class="float">0.087</span>     <span 
class="float">9.30</span>
+HasStep([~label.eq(person)])                                          <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.044</span>     <span class="float">4.73</span>
+PropertiesStep([age],value)                                           <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.058</span>     <span class="float">6.22</span>
+SumGlobalStep                                                          <span 
class="integer">1</span>           <span class="integer">1</span>           
<span class="float">0.154</span>    <span class="float">16.42</span>
+                                            &gt;TOTAL                     -    
       -           <span class="float">0.942</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6835,10 +6841,10 @@ gremlin&gt; metrics = t.getSideEffects()
 ==&gt;Traversal Metrics
 Step                                                               Count  
Traversers       <span class="predefined-type">Time</span> (ms)    % Dur
 
=============================================================================================================
-TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.075</span>   <span 
class="float">319.64</span>
-VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>          
-<span class="float">0.125</span>  -<span class="float">532.15</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                             
                     <span class="integer">4</span>           <span 
class="integer">2</span>           <span class="float">0.073</span>   <span 
class="float">312.51</span>
-                                            &gt;TOTAL                     -    
       -           <span class="float">0.023</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.079</span>   <span 
class="float">541.87</span>
+VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>          
-<span class="float">0.137</span>  -<span class="float">937.85</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                             
                     <span class="integer">4</span>           <span 
class="integer">2</span>           <span class="float">0.072</span>   <span 
class="float">495.97</span>
+                                            &gt;TOTAL                     -    
       -           <span class="float">0.014</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6882,7 +6888,7 @@ gremlin&gt; g.V().has(<span class="strin
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#project-java.lang.String-java.lang.String&#8230;&#8203;-";><code>project(String,String&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#project-java.lang.String-java.lang.String...-";><code>project(String,String&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -7043,7 +7049,7 @@ gremlin&gt; g.V(<span class="integer">1<
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#properties-java.lang.String&#8230;&#8203;-";><code>properties(String&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#properties-java.lang.String...-";><code>properties(String&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -7087,7 +7093,7 @@ gremlin&gt; g.E().propertyMap()
 <p><strong>Additional References</strong></p>
 </div>
 <div class="paragraph">
-<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#propertyMap-java.lang.String&#8230;&#8203;-";><code>propertyMap(String&#8230;&#8203;)</code></a></p>
+<p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#propertyMap-java.lang.String...-";><code>propertyMap(String&#8230;&#8203;)</code></a></p>
 </div>
 </div>
 <div class="sect2">
@@ -7373,14 +7379,14 @@ value is accessed (<code>sack()</code>).
 ==&gt;<span class="float">1.0</span>
 ==&gt;<span class="float">1.0</span>
 gremlin&gt; rand = <span class="keyword">new</span> <span 
class="predefined-type">Random</span>()
-==&gt;java.util.Random<span class="annotation">@bb78f01</span>
+==&gt;java.util.Random<span class="error">@</span><span 
class="float">72e36d</span><span class="float">0f</span>
 gremlin&gt; g.withSack {rand.nextFloat()}.V().sack()
-==&gt;<span class="float">0.18422145</span>
-==&gt;<span class="float">0.88961905</span>
-==&gt;<span class="float">0.81634456</span>
-==&gt;<span class="float">0.28725624</span>
-==&gt;<span class="float">0.44480467</span>
-==&gt;<span class="float">0.2944106</span></code></pre>
+==&gt;<span class="float">0.6277745</span>
+==&gt;<span class="float">0.07332569</span>
+==&gt;<span class="float">0.6435088</span>
+==&gt;<span class="float">0.22704983</span>
+==&gt;<span class="float">0.7388214</span>
+==&gt;<span class="float">0.23112226</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -7511,12 +7517,12 @@ gremlin&gt;</code></pre>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code data-lang="groovy">gremlin&gt; 
g.V().outE().sample(<span class="integer">1</span>).values(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>)
-==&gt;<span class="float">0.5</span>
+==&gt;<span class="float">1.0</span>
 gremlin&gt; g.V().outE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span 
class="delimiter">'</span></span>).values(<span class="string"><span 
class="delimiter">'</span><span class="content">weight</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="float">0.5</span>
+==&gt;<span class="float">1.0</span>
 gremlin&gt; g.V().outE().sample(<span class="integer">2</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span 
class="delimiter">'</span></span>).values(<span class="string"><span 
class="delimiter">'</span><span class="content">weight</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="float">0.5</span>
-==&gt;<span class="float">1.0</span></code></pre>
+==&gt;<span class="float">1.0</span>
+==&gt;<span class="float">0.5</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -7531,15 +7537,15 @@ the traverser never splits and continues
 <pre class="CodeRay highlight"><code data-lang="groovy">gremlin&gt; g.V(<span 
class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">5</span>)
-==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">4</span>]
 gremlin&gt; g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">5</span>).path()
-==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">4</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>]]
+==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>]]
 gremlin&gt; g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">10</span>).path()
-==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">4</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer"
 >5</span>],v[<span class="integer">5</span>],e[<span 
 >class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
 >class="integer">5</span>],v[<span class="integer">4</span>],e[<span 
 >class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
 >class="integer">4</span>],v[<span class="integer">1</span>],e[<span 
 >class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
 >class="integer">3</span>],v[<span class="integer">3</span>]]</code></pre>
+==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">4</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">4</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">5</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">4</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="in
 teger">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">12</span>][<span class="integer">6</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">6</span>],e[<span 
class="integer">12</span>][<span class="integer">6</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">1</span>]]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -7778,7 +7784,7 @@ binding is filtered if <code>a</code> do
 <p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#select-org.apache.tinkerpop.gremlin.structure.Column-";><code>select(Column)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#select-org.apache.tinkerpop.gremlin.process.traversal.Pop-java.lang.String-";><code>select(Pop,String)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#select-java.lang.String-";><code>select(String)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#select-java.lang.String-java.lang.String-java.lang.String&#8230;&#8203;-";><code>select(String,String,String&#8230;&#8203;)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#select-java.lang.String-java.lang.String-java.lang.String...-";><code>select(String,String,String&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/structure/Column.html";><code>Column</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Pop.html";><code>Pop</code></a></p>
 </div>
@@ -8165,7 +8171,7 @@ that can be used to time execution of a
 ==&gt;v[<span class="integer">5</span>]=<span class="integer">1136688</span>
 ==&gt;v[<span class="integer">6</span>]=<span class="integer">1136688</span>
 gremlin&gt; clock(<span class="integer">1</span>) 
{g.V().repeat(both().groupCount(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>)).times(<span 
class="integer">16</span>).cap(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).order(local).by(values,decr).next()}
-==&gt;<span class="float">2.085542</span>
+==&gt;<span class="float">2.431403</span>
 gremlin&gt; g.V().repeat(timeLimit(<span 
class="integer">2</span>).both().groupCount(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>)).times(<span 
class="integer">16</span>).cap(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).order(local).by(values,decr).next()
 ==&gt;v[<span class="integer">1</span>]=<span class="integer">2744208</span>
 ==&gt;v[<span class="integer">3</span>]=<span class="integer">2744208</span>
@@ -8174,7 +8180,7 @@ gremlin&gt; g.V().repeat(timeLimit(<span
 ==&gt;v[<span class="integer">5</span>]=<span class="integer">1136688</span>
 ==&gt;v[<span class="integer">6</span>]=<span class="integer">1136688</span>
 gremlin&gt; clock(<span class="integer">1</span>) 
{g.V().repeat(timeLimit(<span class="integer">2</span>).both().groupCount(<span 
class="string"><span class="delimiter">'</span><span 
class="content">m</span><span class="delimiter">'</span></span>)).times(<span 
class="integer">16</span>).cap(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).order(local).by(values,decr).next()}
-==&gt;<span class="float">1.762213</span></code></pre>
+==&gt;<span class="float">1.6923139999999999</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -8209,7 +8215,7 @@ means by which they are added. The gener
 <p><a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#to-org.apache.tinkerpop.gremlin.process.traversal.Traversal-";><code>to(Direction,String&#8230;&#8203;)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#to-org.apache.tinkerpop.gremlin.process.traversal.Traversal-";><code>to(String)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#to-org.apache.tinkerpop.gremlin.process.traversal.Traversal-";><code>to(Traversal)</code></a>,
-<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#toE-org.apache.tinkerpop.gremlin.structure.Direction-java.lang.String&#8230;&#8203;-";><code>toE(Direction,String)</code></a>,
+<a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#toE-org.apache.tinkerpop.gremlin.structure.Direction-java.lang.String...-";><code>toE(Direction,String)</code></a>,
 <a 
href="http://tinkerpop.apache.org/javadocs/3.2.8-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#toV-org.apache.tinkerpop.gremlin.structure.Direction-";><code>toV(Direction)</code></a>,

[... 1098 lines stripped ...]

Reply via email to