Modified: tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html
URL: 
http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html?rev=1761999&r1=1761998&r2=1761999&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html Thu Sep 22 21:19:13 
2016
@@ -861,7 +861,7 @@ span.line-numbers { border-right: 1px so
 <li><a href="#graph-traversal-steps">Graph Traversal Steps</a></li>
 <li>
 <ul class="sectlevel2">
-<li><a href="#lambda-steps">Lambda Steps</a></li>
+<li><a href="#general-steps">General Steps</a></li>
 <li><a href="#addedge-step">AddEdge Step</a></li>
 <li><a href="#addvertex-step">AddVertex Step</a></li>
 <li><a href="#addproperty-step">AddProperty Step</a></li>
@@ -1997,11 +1997,11 @@ system providers for two purposes:</p>
 gremlin&gt; graph.features()
 ==&gt;FEATURES
 &gt; GraphFeatures
-&gt;-- <span class="key">Computer</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">Transactions</span>: <span 
class="predefined-constant">false</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">Transactions</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>
@@ -2023,10 +2023,11 @@ gremlin&gt; graph.features()
 &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; VertexFeatures
-&gt;-- <span class="key">MultiProperties</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MetaProperties</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">MetaProperties</span>: <span 
class="predefined-constant">true</span>
+&gt;-- <span class="key">MultiProperties</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="key">RemoveProperty</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span 
class="predefined-constant">true</span>
@@ -2034,8 +2035,8 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">UuidIds</span>: <span 
class="predefined-constant">true</span>
 &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">UserSuppliedIds</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>
@@ -2043,7 +2044,6 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">UuidIds</span>: <span 
class="predefined-constant">true</span>
 &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="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>
@@ -2064,8 +2064,9 @@ gremlin&gt; graph.features()
 &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; 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">RemoveEdges</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="key">RemoveProperty</span>: <span 
class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span 
class="predefined-constant">true</span>
@@ -2073,7 +2074,6 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">UuidIds</span>: <span 
class="predefined-constant">true</span>
 &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; 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>
@@ -2352,9 +2352,7 @@ use cases include:</p>
 gremlin&gt; graph.variables()
 ==&gt;variables[<span class="key">size</span>:<span class="integer">0</span>]
 gremlin&gt; graph.variables().set(<span class="string"><span 
class="delimiter">'</span><span class="content">systemAdmins</span><span 
class="delimiter">'</span></span>,[<span class="string"><span 
class="delimiter">'</span><span class="content">stephen</span><span 
class="delimiter">'</span></span>,<span class="string"><span 
class="delimiter">'</span><span class="content">peter</span><span 
class="delimiter">'</span></span>,<span class="string"><span 
class="delimiter">'</span><span class="content">pavel</span><span 
class="delimiter">'</span></span>])
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; graph.variables().set(<span class="string"><span 
class="delimiter">'</span><span class="content">systemUsers</span><span 
class="delimiter">'</span></span>,[<span class="string"><span 
class="delimiter">'</span><span class="content">matthias</span><span 
class="delimiter">'</span></span>,<span class="string"><span 
class="delimiter">'</span><span class="content">marko</span><span 
class="delimiter">'</span></span>,<span class="string"><span 
class="delimiter">'</span><span class="content">josh</span><span 
class="delimiter">'</span></span>])
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; graph.variables().keys()
 ==&gt;systemAdmins
 ==&gt;systemUsers
@@ -2365,7 +2363,6 @@ gremlin&gt; graph.variables().get(<span
 ==&gt;marko
 ==&gt;josh
 gremlin&gt; graph.variables().remove(<span class="string"><span 
class="delimiter">'</span><span class="content">systemAdmins</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; graph.variables().keys()
 ==&gt;systemUsers</code></pre>
 </div>
@@ -2581,8 +2578,7 @@ gremlin&gt; graph.tx().submit {<span cla
 ==&gt;v[<span class="integer">0</span>]
 gremlin&gt; graph.tx().submit {<span 
class="local-variable">it</span>.addVertex(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">name</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">daniel</span><span 
class="delimiter">&quot;</span></span>)}.exponentialBackoff(<span 
class="integer">10</span>)
 ==&gt;v[<span class="integer">1</span>]
-gremlin&gt; graph.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; graph.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2859,9 +2855,7 @@ gremlin&gt; g = graph.traversal()
 gremlin&gt; f = <span class="keyword">new</span> <span 
class="predefined-type">ByteArrayOutputStream</span>()
 ==&gt;
 gremlin&gt; graph.io(graphson()).writer().create().writeVertex(f, g.V(<span 
class="integer">1</span>).next(), BOTH)
-==&gt;<span class="predefined-constant">null</span>
-gremlin&gt; f.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; f.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2940,11 +2934,9 @@ 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">52337</span>eb6
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span 
class="error">@</span><span class="integer">557</span>c837
 gremlin&gt; 
graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span 
class="integer">1</span>).next(), BOTH)
-==&gt;<span class="predefined-constant">null</span>
-gremlin&gt; f.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; f.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -3132,11 +3124,9 @@ 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="error">@</span><span class="integer">37</span>c9dadf
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span 
class="error">@</span><span class="integer">63</span>b5a020
 gremlin&gt; 
graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span 
class="integer">1</span>).next(), BOTH)
-==&gt;<span class="predefined-constant">null</span>
-gremlin&gt; f.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; f.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -3477,24 +3467,9 @@ the verbose syntax <code>__.in()</code>
 </table>
 </div>
 <div class="sect2">
-<h3 id="lambda-steps">Lambda Steps</h3>
-<div class="admonitionblock warning">
-<table>
-<tr>
-<td class="icon">
-<div class="title">Warning</div>
-</td>
-<td class="content">
-Lambda steps are presented for educational purposes as they represent the 
foundational constructs of the
-Gremlin language. In practice, lambda steps should be avoided and traversal 
verification strategies exist to disallow t
-heir use unless explicitly "turned off." For more information on the problems 
with lambdas, please read
-<a href="#a-note-on-lambdas">A Note on Lambdas</a>.
-</td>
-</tr>
-</table>
-</div>
+<h3 id="general-steps">General Steps</h3>
 <div class="paragraph">
-<p>There are four generic steps by which all other specific steps described 
later extend.</p>
+<p>There are five general steps, each having a traversal and a lambda 
representation, by which all other specific steps described later extend.</p>
 </div>
 <table class="tableblock frame-all grid-all" style="width:100%; ">
 <colgroup>
@@ -3509,28 +3484,43 @@ heir use unless explicitly "turned off."
 </thead>
 <tbody>
 <tr>
-<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>map(Function&lt;Traverser&lt;S&gt;, 
E&gt;)</code></p></td>
+<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>map(Traversal&lt;S, E&gt;)</code> &lt;br&gt; 
<code>map(Function&lt;Traverser&lt;S&gt;, E&gt;)</code></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">map the 
traverser to some object of type <code>E</code> for the next step to 
process.</p></td>
 </tr>
 <tr>
-<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>flatMap(Function&lt;Traverser&lt;S&gt;, 
Iterator&lt;E&gt;&gt;)</code></p></td>
+<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>flatMap(Traversal&lt;S, E&gt;)</code> &lt;br&gt; 
<code>flatMap(Function&lt;Traverser&lt;S&gt;, 
Iterator&lt;E&gt;&gt;)</code></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">map the 
traverser to an iterator of <code>E</code> objects that are streamed to the 
next step.</p></td>
 </tr>
 <tr>
-<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>filter(Predicate&lt;Traverser&lt;S&gt;&gt;)</code></p></td>
+<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>filter(Traversal&lt;?, ?&gt;)</code> &lt;br&gt; 
<code>filter(Predicate&lt;Traverser&lt;S&gt;&gt;)</code></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">map the 
traverser to either true or false, where false will not pass the traverser to 
the next step.</p></td>
 </tr>
 <tr>
-<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>sideEffect(Consumer&lt;Traverser&lt;S&gt;&gt;)</code></p></td>
+<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>sideEffect(Traversal&lt;S, S&gt;)</code> &lt;br&gt; 
<code>sideEffect(Consumer&lt;Traverser&lt;S&gt;&gt;)</code></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">perform 
some operation on the traverser and pass it to the next step.</p></td>
 </tr>
 <tr>
-<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>branch(Function&lt;Traverser&lt;S&gt;,M&gt;)</code></p></td>
+<td class="tableblock halign-left valign-top"><p 
class="tableblock"><code>branch(Traversal&lt;S, M&gt;)</code> &lt;br&gt; 
<code>branch(Function&lt;Traverser&lt;S&gt;,M&gt;)</code></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">split the 
traverser to all the traversals indexed by the <code>M</code> token.</p></td>
 </tr>
 </tbody>
 </table>
 
+<div class="admonitionblock warning">
+<table>
+<tr>
+<td class="icon">
+<div class="title">Warning</div>
+</td>
+<td class="content">
+Lambda steps are presented for educational purposes as they represent the 
foundational constructs of the
+Gremlin language. In practice, lambda steps should be avoided in favor of 
their traversals representation and traversal
+verification strategies exist to disallow their use unless explicitly "turned 
off." For more information on the problems
+with lambdas, please read <a href="#a-note-on-lambdas">A Note on Lambdas</a>.
+</td>
+</tr>
+</table>
+</div>
 <div class="paragraph">
 <p>The <code>Traverser&lt;S&gt;</code> object provides access to:</p>
 </div>
@@ -3582,6 +3572,10 @@ heir use unless explicitly "turned off."
 gremlin&gt; g.V(<span class="integer">1</span>).out().map {<span 
class="local-variable">it</span>.get().value(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)} <span class="comment">//</span><b>(2)</b>
 ==&gt;lop
 ==&gt;vadas
+==&gt;josh
+gremlin&gt; g.V(<span class="integer">1</span>).out().map(values(<span 
class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>)) <span 
class="comment">//</span><b>(3)</b>
+==&gt;lop
+==&gt;vadas
 ==&gt;josh</code></pre>
 </div>
 </div>
@@ -3593,6 +3587,9 @@ gremlin&gt; g.V(<span class="integer">1<
 <li>
 <p>The same operation, but using a lambda to access the name property 
values.</p>
 </li>
+<li>
+<p>Again the same operation, but using the traversal representation of 
<code>map()</code>.</p>
+</li>
 </ol>
 </div>
 <div class="paragraph">
@@ -3605,7 +3602,12 @@ gremlin&gt; g.V(<span class="integer">1<
 ==&gt;v[<span class="integer">2</span>]
 ==&gt;v[<span class="integer">4</span>]
 ==&gt;v[<span class="integer">6</span>]
-gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>) <span class="comment">//</span><b>(2)</b>
+gremlin&gt; g.V().filter(label().is(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>)) <span class="comment">//</span><b>(2)</b>
+==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">2</span>]
+==&gt;v[<span class="integer">4</span>]
+==&gt;v[<span class="integer">6</span>]
+gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>) <span class="comment">//</span><b>(3)</b>
 ==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">2</span>]
 ==&gt;v[<span class="integer">4</span>]
@@ -3618,6 +3620,9 @@ gremlin&gt; g.V().hasLabel(<span class="
 <p>A filter that only allows the vertex to pass if it has an age-property.</p>
 </li>
 <li>
+<p>The same operation, but using the traversal represention of 
<code>filter()</code>.</p>
+</li>
+<li>
 <p>The more specific <code>has()</code>-step is implemented as a 
<code>filter()</code> with respective predicate.</p>
 </li>
 </ol>
@@ -3635,7 +3640,10 @@ v[<span class="integer">2</span>]
 v[<span class="integer">4</span>]
 ==&gt;v[<span class="integer">4</span>]
 v[<span class="integer">6</span>]
-==&gt;v[<span class="integer">6</span>]</code></pre>
+==&gt;v[<span class="integer">6</span>]
+gremlin&gt; g.V().sideEffect(outE().count().store(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">o</span><span 
class="delimiter">&quot;</span></span>)).
+               sideEffect(inE().count().store(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">i</span><span 
class="delimiter">&quot;</span></span>)).cap(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">o</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">i</span><span 
class="delimiter">&quot;</span></span>) <span 
class="comment">//</span><b>(2)</b>
+==&gt;[<span class="key">i</span>:[<span class="integer">0</span>,<span 
class="integer">0</span>,<span class="integer">1</span>,<span 
class="integer">1</span>,<span class="integer">1</span>,<span 
class="integer">3</span>],<span class="key">o</span>:[<span 
class="integer">3</span>,<span class="integer">0</span>,<span 
class="integer">0</span>,<span class="integer">0</span>,<span 
class="integer">2</span>,<span class="integer">1</span>]]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -3643,6 +3651,9 @@ v[<span class="integer">6</span>]
 <li>
 <p>Whatever enters <code>sideEffect()</code> is passed to the next step, but 
some intervening process can occur.</p>
 </li>
+<li>
+<p>Compute the out- and in-degree for each vertex. Both 
<code>sideEffect()</code> are fed with the same vertex.</p>
+</li>
 </ol>
 </div>
 <div class="paragraph">
@@ -3650,7 +3661,7 @@ v[<span class="integer">6</span>]
 </div>
 <div class="listingblock">
 <div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().branch(values(<span class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>)).
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().branch {<span class="local-variable">it</span>.get().value(<span 
class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>)}.
                option(<span class="string"><span 
class="delimiter">'</span><span class="content">marko</span><span 
class="delimiter">'</span></span>, values(<span class="string"><span 
class="delimiter">'</span><span class="content">age</span><span 
class="delimiter">'</span></span>)).
                option(none, values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)) <span class="comment">//</span><b>(1)</b>
 ==&gt;<span class="integer">29</span>
@@ -3659,9 +3670,18 @@ v[<span class="integer">6</span>]
 ==&gt;josh
 ==&gt;ripple
 ==&gt;peter
+gremlin&gt; g.V().branch(values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)).
+               option(<span class="string"><span 
class="delimiter">'</span><span class="content">marko</span><span 
class="delimiter">'</span></span>, values(<span class="string"><span 
class="delimiter">'</span><span class="content">age</span><span 
class="delimiter">'</span></span>)).
+               option(none, values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)) <span class="comment">//</span><b>(2)</b>
+==&gt;<span class="integer">29</span>
+==&gt;vadas
+==&gt;lop
+==&gt;josh
+==&gt;ripple
+==&gt;peter
 gremlin&gt; g.V().choose(has(<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">marko</span><span 
class="delimiter">'</span></span>),
                       values(<span class="string"><span 
class="delimiter">'</span><span class="content">age</span><span 
class="delimiter">'</span></span>),
-                      values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)) <span class="comment">//</span><b>(2)</b>
+                      values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)) <span class="comment">//</span><b>(3)</b>
 ==&gt;<span class="integer">29</span>
 ==&gt;vadas
 ==&gt;lop
@@ -3676,6 +3696,9 @@ gremlin&gt; g.V().choose(has(<span class
 <p>If the vertex is "marko", get his age, else get the name of the vertex.</p>
 </li>
 <li>
+<p>The same operation, but using the traversal represention of 
<code>branch()</code>.</p>
+</li>
+<li>
 <p>The more specific boolean-based <code>choose()</code>-step is implemented 
as a <code>branch()</code>.</p>
 </li>
 </ol>
@@ -4020,17 +4043,16 @@ made more salient on a larger graph. The
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; graph = 
TinkerGraph.open()
 ==&gt;tinkergraph[<span class="key">vertices</span>:<span 
class="integer">0</span> <span class="key">edges</span>:<span 
class="integer">0</span>]
 gremlin&gt; graph.io(graphml()).readGraph(<span class="string"><span 
class="delimiter">'</span><span 
class="content">data/grateful-dead.xml</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; g = graph.traversal()
 ==&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="comment">//</span><b>(1)</b>
-==&gt;<span class="float">14317.232571999999</span>
+==&gt;<span class="float">8669.263931</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="comment">//</span><b>(2)</b>
-==&gt;<span class="float">20.356651</span>
+==&gt;<span class="float">14.115905</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="comment">//</span><b>(3)</b>
-==&gt;<span class="float">27.261338</span>
+==&gt;<span class="float">14.185149</span>
 ==&gt;<span class="integer">126653966</span></code></pre>
 </div>
 </div>
@@ -4061,11 +4083,10 @@ optimization scenario, but reduces the r
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; graph = 
TinkerGraph.open()
 ==&gt;tinkergraph[<span class="key">vertices</span>:<span 
class="integer">0</span> <span class="key">edges</span>:<span 
class="integer">0</span>]
 gremlin&gt; graph.io(graphml()).readGraph(<span class="string"><span 
class="delimiter">'</span><span 
class="content">data/grateful-dead.xml</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; g = 
graph.traversal().withStrategies(LazyBarrierStrategy.instance())
 ==&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">17.443212</span>
+==&gt;<span class="float">11.988038</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; g.V().both().both().both().count().iterate().toString() <span 
class="comment">//</span><b>(1)</b>
 ==&gt;[TinkerGraphStep(vertex,<span class="type">[]</span>), 
VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">10000</span>), 
VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">10000</span>), 
VertexStep(BOTH,edge), CountGlobalStep]</code></pre>
@@ -4287,9 +4308,8 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().coin(<span class="float">0.5</span>)
 ==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">3</span>]
-==&gt;v[<span class="integer">4</span>]
-==&gt;v[<span class="integer">6</span>]
+==&gt;v[<span class="integer">2</span>]
+==&gt;v[<span class="integer">5</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>]
@@ -4408,12 +4428,12 @@ has been seen or not.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-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">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>,<span class="key">name</span>:[marko]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">2</span>,<span class="key">name</span>:[vadas]]
-==&gt;[<span class="key">label</span>:software,<span 
class="key">id</span>:<span class="integer">3</span>,<span 
class="key">name</span>:[lop]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">4</span>,<span class="key">name</span>:[josh]]
-==&gt;[<span class="key">label</span>:software,<span 
class="key">id</span>:<span class="integer">5</span>,<span 
class="key">name</span>:[ripple]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">6</span>,<span class="key">name</span>:[peter]]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>]
+==&gt;[<span class="key">name</span>:[vadas],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">2</span>]
+==&gt;[<span class="key">name</span>:[lop],<span 
class="key">label</span>:software,<span class="key">id</span>:<span 
class="integer">3</span>]
+==&gt;[<span class="key">name</span>:[josh],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">4</span>]
+==&gt;[<span class="key">name</span>:[ripple],<span 
class="key">label</span>:software,<span class="key">id</span>:<span 
class="integer">5</span>]
+==&gt;[<span class="key">name</span>:[peter],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">6</span>]
 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>
@@ -4493,13 +4513,13 @@ Original Traversal                 [Grap
 
 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>))]
 IdentityRemovalStrategy      [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
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), 
EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,vertex), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-MatchPredicateStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-PathRetractionStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+PathRetractionStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
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), 
RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 ProfileStrategy              [F]   
[TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), 
RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 StandardVerificationStrategy [V]   
[TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), 
RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), 
CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
@@ -4593,10 +4613,10 @@ Whether a mid-traversal <code>V()</code>
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().has(<span class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>, 
within(<span class="string"><span class="delimiter">'</span><span 
class="content">marko</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">vadas</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">josh</span><span class="delimiter">'</span></span>)).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">person</span><span class="delimiter">'</span></span>).
            V().has(<span class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>, 
within(<span class="string"><span class="delimiter">'</span><span 
class="content">lop</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">ripple</span><span 
class="delimiter">'</span></span>)).addE(<span class="string"><span 
class="delimiter">'</span><span class="content">uses</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).toString() <span 
class="comment">//</span><b>(1)</b>
-==&gt;[GraphStep(vertex,<span class="type">[]</span>), 
HasStep([name.within([marko, vadas, josh])])<span 
class="error">@</span>[person], GraphStep(vertex,<span class="type">[]</span>), 
HasStep([name.within([lop, ripple])]), AddEdgeStep({label=[uses], 
~from=[[SelectOneStep(person)]]})]
+==&gt;[GraphStep(vertex,<span class="type">[]</span>), 
HasStep([name.within([marko, vadas, josh])])<span 
class="error">@</span>[person], GraphStep(vertex,<span class="type">[]</span>), 
HasStep([name.within([lop, ripple])]), 
AddEdgeStep({~from=[[SelectOneStep(person)]], label=[uses]})]
 gremlin&gt; g.V().has(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>, within(<span class="string"><span 
class="delimiter">'</span><span class="content">marko</span><span 
class="delimiter">'</span></span>, <span class="string"><span 
class="delimiter">'</span><span class="content">vadas</span><span 
class="delimiter">'</span></span>, <span class="string"><span 
class="delimiter">'</span><span class="content">josh</span><span 
class="delimiter">'</span></span>)).as(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).
            V().has(<span class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>, 
within(<span class="string"><span class="delimiter">'</span><span 
class="content">lop</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">ripple</span><span 
class="delimiter">'</span></span>)).addE(<span class="string"><span 
class="delimiter">'</span><span class="content">uses</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).iterate().toString() <span 
class="comment">//</span><b>(2)</b>
-==&gt;[TinkerGraphStep(vertex,[name.within([marko, vadas, josh])])<span 
class="error">@</span>[person], TinkerGraphStep(vertex,[name.within([lop, 
ripple])]), AddEdgeStep({label=[uses], ~from=[[SelectOneStep(person), 
NoOpBarrierStep(<span class="integer">2500</span>)]]})]</code></pre>
+==&gt;[TinkerGraphStep(vertex,[name.within([marko, vadas, josh])])<span 
class="error">@</span>[person], TinkerGraphStep(vertex,[name.within([lop, 
ripple])]), AddEdgeStep({~from=[[SelectOneStep(person), NoOpBarrierStep(<span 
class="integer">2500</span>)]], label=[uses]})]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -5105,7 +5125,6 @@ songs which Jerry Garcia has both sung a
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
graph.io(graphml()).readGraph(<span class="string"><span 
class="delimiter">'</span><span 
class="content">data/grateful-dead.xml</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; g = graph.traversal()
 ==&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; g.V().match(
@@ -5313,7 +5332,6 @@ optimizer within <code>match()</code>-st
                              __.as(<span class="string"><span 
class="delimiter">'</span><span class="content">b</span><span 
class="delimiter">'</span></span>).in(<span class="string"><span 
class="delimiter">'</span><span class="content">created</span><span 
class="delimiter">'</span></span>).as(<span class="string"><span 
class="delimiter">'</span><span class="content">c</span><span 
class="delimiter">'</span></span>)).
                              where(__.as(<span class="string"><span 
class="delimiter">'</span><span class="content">a</span><span 
class="delimiter">'</span></span>).out(<span class="string"><span 
class="delimiter">'</span><span class="content">knows</span><span 
class="delimiter">'</span></span>).as(<span class="string"><span 
class="delimiter">'</span><span class="content">c</span><span 
class="delimiter">'</span></span>)). <span class="comment">//</span><b>(2)</b>
                            select(<span class="string"><span 
class="delimiter">'</span><span class="content">a</span><span 
class="delimiter">'</span></span>,<span class="string"><span 
class="delimiter">'</span><span class="content">c</span><span 
class="delimiter">'</span></span>).by(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>); <span 
class="predefined-constant">null</span> <span 
class="comment">//</span><b>(3)</b>
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; traversal.toString() <span class="comment">//</span><b>(4)</b>
 ==&gt;[GraphStep(vertex,<span class="type">[]</span>), 
MatchStep(AND,[[MatchStartStep(a), HasStep([~label.eq(person)]), MatchEndStep], 
[MatchStartStep(a), VertexStep(OUT,[created],vertex), MatchEndStep(b)], 
[MatchStartStep(b), VertexStep(IN,[created],vertex), MatchEndStep(c)]]), 
WhereTraversalStep([WhereStartStep(a), VertexStep(OUT,[knows],vertex), 
WhereEndStep(c)]), SelectStep([a, c],[value(name)])]
 gremlin&gt; traversal <span class="comment">// </span><b>(5)</b> <b>(6)</b>
@@ -5626,15 +5644,15 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-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">2</span>]
 ==&gt;v[<span class="integer">6</span>]
-==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">4</span>]
-==&gt;v[<span class="integer">2</span>]
+==&gt;v[<span class="integer">1</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">6</span>]
-==&gt;v[<span class="integer">1</span>]</code></pre>
+==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">4</span>]
+==&gt;v[<span class="integer">2</span>]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -5707,19 +5725,19 @@ The <code>pageRank()</code>-step is a <c
 <pre class="CodeRay"><code class="groovy language-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.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>
-==&gt;<span class="float">0.23181250000000003</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>)).
              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>)
-==&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.21375000000000002</span>],<span class="key">name</span>:[vadas]]
 ==&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>
@@ -5737,45 +5755,45 @@ 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]]), PropertyMa
-                                      pStep([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]]), PropertyMa
-                                      pStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-IdentityRemovalStrategy      [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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]]), PropertyMapS
+                                      tep([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]), TraversalV
+                                      
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+ConnectiveStrategy           [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]), TraversalV
+                                      
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+IdentityRemovalStrategy      [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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([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]), Traversa
-                                      
lVertexProgramStep([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]), TraversalV
+                                      
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]</code></pre>
 </div>
 </div>
 </div>
@@ -5927,7 +5945,7 @@ gremlin&gt; g.V().peerPressure().by(<spa
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).
            peerPressure().by(<span class="string"><span 
class="delimiter">'</span><span class="content">cluster</span><span 
class="delimiter">'</span></span>).
            group().by(<span class="string"><span 
class="delimiter">'</span><span class="content">cluster</span><span 
class="delimiter">'</span></span>).by(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)
-==&gt;[<span class="integer">1</span>:[marko,josh,vadas],<span 
class="integer">6</span>:[peter]]</code></pre>
+==&gt;[<span class="integer">1</span>:[marko,vadas,josh],<span 
class="integer">6</span>:[peter]]</code></pre>
 </div>
 </div>
 </div>
@@ -5956,18 +5974,18 @@ 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.455</span>     <span 
class="float">9.61</span>
-VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>           
<span class="float">0.527</span>    <span class="float">11.13</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">10</span>          <span class="integer">10</span>           
<span class="float">0.507</span>    <span class="float">10.72</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">10</span>           <span 
class="integer">3</span>           <span class="float">0.483</span>    <span 
class="float">10.20</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">24</span>           <span class="integer">7</span>           
<span class="float">0.361</span>     <span class="float">7.63</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">24</span>           <span 
class="integer">5</span>           <span class="float">0.442</span>     <span 
class="float">9.33</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">58</span>          <span class="integer">11</span>           
<span class="float">0.518</span>    <span class="float">10.94</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">58</span>           <span 
class="integer">6</span>           <span class="float">0.526</span>    <span 
class="float">11.12</span>
-HasStep([~label.eq(person)])                                          <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.330</span>     <span class="float">6.98</span>
-PropertiesStep([age],value)                                           <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.263</span>     <span class="float">5.56</span>
-SumGlobalStep                                                          <span 
class="integer">1</span>           <span class="integer">1</span>           
<span class="float">0.320</span>     <span class="float">6.77</span>
-                                            &gt;TOTAL                     -    
       -           <span class="float">4.738</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.073</span>    <span 
class="float">11.80</span>
+VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>           
<span class="float">0.102</span>    <span class="float">16.37</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">10</span>          <span class="integer">10</span>           
<span class="float">0.063</span>    <span class="float">10.11</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">10</span>           <span 
class="integer">3</span>           <span class="float">0.068</span>    <span 
class="float">11.02</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">24</span>           <span class="integer">7</span>           
<span class="float">0.028</span>     <span class="float">4.50</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">24</span>           <span 
class="integer">5</span>           <span class="float">0.027</span>     <span 
class="float">4.47</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">58</span>          <span class="integer">11</span>           
<span class="float">0.035</span>     <span class="float">5.74</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">58</span>           <span 
class="integer">6</span>           <span class="float">0.044</span>     <span 
class="float">7.17</span>
+HasStep([~label.eq(person)])                                          <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.033</span>     <span class="float">5.31</span>
+PropertiesStep([age],value)                                           <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.056</span>     <span class="float">9.13</span>
+SumGlobalStep                                                          <span 
class="integer">1</span>           <span class="integer">1</span>           
<span class="float">0.089</span>    <span class="float">14.37</span>
+                                            &gt;TOTAL                     -    
       -           <span class="float">0.623</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6015,9 +6033,9 @@ 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.226</span>    <span 
class="float">90.21</span>
-VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>           
<span class="float">0.024</span>     <span class="float">9.79</span>
-                                            &gt;TOTAL                     -    
       -           <span class="float">0.251</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.140</span>   -<span 
class="float">78.16</span>
+VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>          
-<span class="float">0.319</span>   <span class="float">178.16</span>
+                                            &gt;TOTAL                     -    
       -          -<span class="float">0.179</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6169,8 +6187,8 @@ gremlin&gt; g.V().hasLabel(<span class="
            program(PageRankVertexProgram.build().property(<span 
class="string"><span class="delimiter">'</span><span 
class="content">rank</span><span 
class="delimiter">'</span></span>).create(graph)).
              order().by(<span class="string"><span 
class="delimiter">'</span><span class="content">rank</span><span 
class="delimiter">'</span></span>, incr).
            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">rank</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="key">name</span>:[marko],<span 
class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
 ==&gt;[<span class="key">name</span>:[peter],<span 
class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
 ==&gt;[<span class="key">name</span>:[vadas],<span 
class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]
 ==&gt;[<span class="key">name</span>:[josh],<span 
class="key">rank</span>:[<span 
class="float">0.19250000000000003</span>]]</code></pre>
 </div>
@@ -6438,14 +6456,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="error">@</span><span 
class="float">3d</span>fe520
+==&gt;java.util.Random<span class="error">@</span><span 
class="float">6567d</span>e86
 gremlin&gt; g.withSack {rand.nextFloat()}.V().sack()
-==&gt;<span class="float">0.8255876</span>
-==&gt;<span class="float">0.1542666</span>
-==&gt;<span class="float">0.5551805</span>
-==&gt;<span class="float">0.32227212</span>
-==&gt;<span class="float">0.60015833</span>
-==&gt;<span class="float">0.414905</span></code></pre>
+==&gt;<span class="float">0.6391494</span>
+==&gt;<span class="float">0.8057445</span>
+==&gt;<span class="float">0.7621683</span>
+==&gt;<span class="float">0.85526294</span>
+==&gt;<span class="float">0.10751295</span>
+==&gt;<span class="float">0.51945925</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6556,7 +6574,7 @@ gremlin&gt; g.withBulk(<span class="pred
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-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">1.0</span>
+==&gt;<span class="float">0.5</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">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>)
@@ -6576,15 +6594,15 @@ the traverser never splits and continues
 <pre class="CodeRay"><code class="groovy language-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">2</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">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">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">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">5</span>]]
+==&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">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">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</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">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">1</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">2</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">1</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">2</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</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>],e[<span class="integer">10</span>][<span 
class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span 
class="integer">5</span>]]</code></pre>
+==&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">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">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">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="inte
 ger">5</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">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">5</span>]]</code></pre>
 </div>
 </div>
 </div>
@@ -6682,7 +6700,6 @@ ranking.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
graph.io(graphml()).readGraph(<span class="string"><span 
class="delimiter">'</span><span 
class="content">data/grateful-dead.xml</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; g = graph.traversal()
 ==&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; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">song</span><span 
class="delimiter">'</span></span>).out(<span class="string"><span 
class="delimiter">'</span><span class="content">followedBy</span><span 
class="delimiter">'</span></span>).groupCount().by(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>).
@@ -6706,7 +6723,6 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
graph.io(graphml()).readGraph(<span class="string"><span 
class="delimiter">'</span><span 
class="content">data/grateful-dead.xml</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; g = graph.traversal()
 ==&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; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">song</span><span 
class="delimiter">'</span></span>).out(<span class="string"><span 
class="delimiter">'</span><span class="content">sungBy</span><span 
class="delimiter">'</span></span>).groupCount().by(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>) <span class="comment">//</span><b>(1)</b>
@@ -7095,7 +7111,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">4.547744</span>
+==&gt;<span class="float">1.335103</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>
@@ -7104,7 +7120,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">4.675629</span></code></pre>
+==&gt;<span class="float">1.218626</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -7302,30 +7318,30 @@ returned map.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().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">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>,<span class="key">name</span>:[marko],<span 
class="key">location</span>:[san diego,santa cruz,brussels,santa fe]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">7</span>,<span class="key">name</span>:[stephen],<span 
class="key">location</span>:[centreville,dulles,purcellville]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">8</span>,<span class="key">name</span>:[matthias],<span 
class="key">location</span>:[bremen,baltimore,oakland,seattle]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">9</span>,<span class="key">name</span>:[daniel],<span 
class="key">location</span>:[spremberg,kaiserslautern,aachen]]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">location</span>:[san diego,santa cruz,brussels,santa fe],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>]
+==&gt;[<span class="key">name</span>:[stephen],<span 
class="key">location</span>:[centreville,dulles,purcellville],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">7</span>]
+==&gt;[<span class="key">name</span>:[matthias],<span 
class="key">location</span>:[bremen,baltimore,oakland,seattle],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">8</span>]
+==&gt;[<span class="key">name</span>:[daniel],<span 
class="key">location</span>:[spremberg,kaiserslautern,aachen],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">9</span>]
 gremlin&gt; g.V().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>,<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>,<span class="key">name</span>:[marko]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">7</span>,<span class="key">name</span>:[stephen]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">8</span>,<span class="key">name</span>:[matthias]]
-==&gt;[<span class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">9</span>,<span class="key">name</span>:[daniel]]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>]
+==&gt;[<span class="key">name</span>:[stephen],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">7</span>]
+==&gt;[<span class="key">name</span>:[matthias],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">8</span>]
+==&gt;[<span class="key">name</span>:[daniel],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">9</span>]
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).properties(<span class="string"><span 
class="delimiter">'</span><span class="content">location</span><span 
class="delimiter">'</span></span>).valueMap(<span 
class="predefined-constant">true</span>)
-==&gt;[<span class="key">id</span>:<span class="integer">6</span>,<span 
class="key">value</span>:san diego,<span class="key">startTime</span>:<span 
class="integer">1997</span>,<span class="key">endTime</span>:<span 
class="integer">2001</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span 
class="key">value</span>:santa cruz,<span class="key">startTime</span>:<span 
class="integer">2001</span>,<span class="key">endTime</span>:<span 
class="integer">2004</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span 
class="key">value</span>:brussels,<span class="key">startTime</span>:<span 
class="integer">2004</span>,<span class="key">endTime</span>:<span 
class="integer">2005</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span 
class="key">value</span>:santa fe,<span class="key">startTime</span>:<span 
class="integer">2005</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">10</span>,<span 
class="key">value</span>:centreville,<span class="key">startTime</span>:<span 
class="integer">1990</span>,<span class="key">endTime</span>:<span 
class="integer">2000</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">11</span>,<span 
class="key">value</span>:dulles,<span class="key">startTime</span>:<span 
class="integer">2000</span>,<span class="key">endTime</span>:<span 
class="integer">2006</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">12</span>,<span 
class="key">value</span>:purcellville,<span class="key">startTime</span>:<span 
class="integer">2006</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">13</span>,<span 
class="key">value</span>:bremen,<span class="key">startTime</span>:<span 
class="integer">2004</span>,<span class="key">endTime</span>:<span 
class="integer">2007</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">14</span>,<span 
class="key">value</span>:baltimore,<span class="key">startTime</span>:<span 
class="integer">2007</span>,<span class="key">endTime</span>:<span 
class="integer">2011</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">15</span>,<span 
class="key">value</span>:oakland,<span class="key">startTime</span>:<span 
class="integer">2011</span>,<span class="key">endTime</span>:<span 
class="integer">2014</span>,<span class="key">key</span>:location]
-==&gt;[<span class="key">id</span>:<span class="integer">16</span>,<span 
class="key">value</span>:seattle,<span class="key">startTime</span>:<span 
class="integer">2014</span>,<span class="key">key</span>:location]

[... 929 lines stripped ...]


Reply via email to