tinkerpop-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From spmalle...@apache.org
Subject svn commit: r1783487 [2/35] - in /tinkerpop/site: docs/3.2.5-SNAPSHOT/dev/provider/ docs/3.2.5-SNAPSHOT/recipes/ docs/3.2.5-SNAPSHOT/reference/ docs/3.2.5-SNAPSHOT/tutorials/the-gremlin-console/ docs/3.2.5-SNAPSHOT/upgrade/ javadocs/3.2.5-SNAPSHOT/core...
Date Sat, 18 Feb 2017 01:43:03 GMT
Modified: tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html?rev=1783487&r1=1783486&r2=1783487&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html Sat Feb 18 01:43:01 2017
@@ -886,10 +886,14 @@ span.line-numbers { border-right: 1px so
 <li><a href="#group-step">Group Step</a></li>
 <li><a href="#groupcount-step">GroupCount Step</a></li>
 <li><a href="#has-step">Has Step</a></li>
+<li><a href="#id-step">Id Step</a></li>
 <li><a href="#inject-step">Inject Step</a></li>
 <li><a href="#is-step">Is Step</a></li>
+<li><a href="#label-step">Label Step</a></li>
+<li><a href="#key-step">Key Step</a></li>
 <li><a href="#limit-step">Limit Step</a></li>
 <li><a href="#local-step">Local Step</a></li>
+<li><a href="#loops-step">Loops Step</a></li>
 <li><a href="#match-step">Match Step</a></li>
 <li>
 <ul class="sectlevel3">
@@ -915,6 +919,8 @@ span.line-numbers { border-right: 1px so
 <li><a href="#profile-step">Profile Step</a></li>
 <li><a href="#project-step">Project Step</a></li>
 <li><a href="#program-step">Program Step</a></li>
+<li><a href="#_properties_step">Properties Step</a></li>
+<li><a href="#propertymap-step">PropertyMap Step</a></li>
 <li><a href="#range-step">Range Step</a></li>
 <li><a href="#repeat-step">Repeat Step</a></li>
 <li><a href="#sack-step">Sack Step</a></li>
@@ -934,7 +940,9 @@ span.line-numbers { border-right: 1px so
 <li><a href="#tree-step">Tree Step</a></li>
 <li><a href="#unfold-step">Unfold Step</a></li>
 <li><a href="#union-step">Union Step</a></li>
+<li><a href="#value-step">Value Step</a></li>
 <li><a href="#valuemap-step">ValueMap Step</a></li>
+<li><a href="#_values_step">Values Step</a></li>
 <li><a href="#vertex-steps">Vertex Steps</a></li>
 <li><a href="#where-step">Where Step</a></li>
 </ul>
@@ -2009,16 +2017,12 @@ gremlin&gt; graph.features()
 ==&gt;FEATURES
 &gt; GraphFeatures
 &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">Transactions</span>: <span class="predefined-constant">false</span>
+&gt;-- <span class="key">Persistence</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>
@@ -2033,12 +2037,17 @@ gremlin&gt; graph.features()
 &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; VertexFeatures
 &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">MetaProperties</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">RemoveVertices</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>
@@ -2046,8 +2055,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>
@@ -2055,12 +2064,7 @@ 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>
-&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>
@@ -2075,9 +2079,14 @@ gremlin&gt; graph.features()
 &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; 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">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>
@@ -2085,13 +2094,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; 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>
@@ -2106,6 +2110,10 @@ gremlin&gt; graph.features()
 &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>
 </code></pre>
 </div>
 </div>
@@ -2364,9 +2372,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
@@ -2377,7 +2383,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>
@@ -2593,8 +2598,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">
@@ -2871,9 +2875,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">
@@ -2952,11 +2954,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">2</span>ccc53ed
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="float">8e101</span>b4
 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">
@@ -3144,11 +3144,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">52</span>aeddab
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">111494</span>bc
 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">
@@ -3742,14 +3740,14 @@ gremlin&gt; g.V().out(<span class="strin
 ==&gt;v[<span class="integer">3</span>]
 gremlin&gt; g.V().out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).next(<span class="integer">2</span>) <span class="comment">//</span><b>(3)</b>
 ==&gt;v[<span class="integer">3</span>]
-==&gt;v[<span class="integer">3</span>]
+==&gt;v[<span class="integer">5</span>]
 gremlin&gt; g.V().out(<span class="string"><span class="delimiter">'</span><span class="content">nothing</span><span class="delimiter">'</span></span>).tryNext() <span class="comment">//</span><b>(4)</b>
 ==&gt;Optional.empty
 gremlin&gt; g.V().out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).toList() <span class="comment">//</span><b>(5)</b>
 ==&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>]
-==&gt;v[<span class="integer">5</span>]
 gremlin&gt; g.V().out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).toSet() <span class="comment">//</span><b>(6)</b>
 ==&gt;v[<span class="integer">3</span>]
 ==&gt;v[<span class="integer">5</span>]
@@ -3765,9 +3763,9 @@ gremlin&gt; g.V().out(<span class="strin
 ==&gt;blah
 ==&gt;<span class="integer">3</span>
 ==&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>]
-==&gt;v[<span class="integer">5</span>]</code></pre>
+==&gt;v[<span class="integer">3</span>]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -3962,9 +3960,9 @@ gremlin&gt; g.V(<span class="integer">1<
 ==&gt;v[<span class="integer">6</span>]
 gremlin&gt; g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>).in(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(4)</b>
 ==&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>]
-==&gt;v[<span class="integer">5</span>]
 gremlin&gt; g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>).in(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).
                 where(without(<span class="string"><span class="delimiter">'</span><span class="content">x</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>(5)</b>
 ==&gt;ripple</code></pre>
@@ -4141,17 +4139,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().withoutStrategies(LazyBarrierStrategy) <span class="comment">//</span><b>(1)</b>
 ==&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>(2)</b>
-==&gt;<span class="float">9451.766706</span>
+==&gt;<span class="float">8293.435082</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>(3)</b>
-==&gt;<span class="float">16.435537999999998</span>
+==&gt;<span class="float">24.497802999999998</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>(4)</b>
-==&gt;<span class="float">13.846613</span>
+==&gt;<span class="float">14.775952</span>
 ==&gt;<span class="integer">126653966</span></code></pre>
 </div>
 </div>
@@ -4185,11 +4182,10 @@ optimization scenario with the added ben
 <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() <span class="comment">//</span><b>(1)</b>
 ==&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">9.783489999999999</span>
+==&gt;<span class="float">11.987064</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; g.V().both().both().both().count().iterate().toString() <span class="comment">//</span><b>(2)</b>
 ==&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>
@@ -4311,17 +4307,17 @@ gremlin&gt; g.V().hasLabel(<span class="
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().choose(hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>), out(<span class="string"><span class="delimiter">'</span><span class="content">created</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>(1)</b>
 ==&gt;lop
 ==&gt;lop
-==&gt;lop
-==&gt;lop
 ==&gt;ripple
+==&gt;lop
 ==&gt;ripple
-gremlin&gt; g.V().choose(hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>), out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>), identity()).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;lop
+gremlin&gt; g.V().choose(hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>), out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>), identity()).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;lop
 ==&gt;lop
+==&gt;ripple
 ==&gt;lop
 ==&gt;ripple
-==&gt;ripple</code></pre>
+==&gt;lop</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -4398,7 +4394,10 @@ 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().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">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>]
@@ -4433,8 +4432,8 @@ gremlin&gt; g.V().coalesce(
 ==&gt;marko
 ==&gt;vadas
 ==&gt;inhuman
-==&gt;inhuman
 ==&gt;josh
+==&gt;inhuman
 ==&gt;peter</code></pre>
 </div>
 </div>
@@ -4512,12 +4511,12 @@ traversal computation. If non-cyclic beh
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V(<span class="integer">1</span>).both().both()
 ==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">1</span>]
-==&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">5</span>]
 ==&gt;v[<span class="integer">3</span>]
+==&gt;v[<span class="integer">1</span>]
 gremlin&gt; g.V(<span class="integer">1</span>).both().both().cyclicPath()
 ==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">1</span>]
@@ -4563,12 +4562,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">id</span>:<span class="integer">1</span>,<span class="key">label</span>:person,<span class="key">name</span>:[marko]]
-==&gt;[<span class="key">id</span>:<span class="integer">2</span>,<span class="key">label</span>:person,<span class="key">name</span>:[vadas]]
-==&gt;[<span class="key">id</span>:<span class="integer">3</span>,<span class="key">label</span>:software,<span class="key">name</span>:[lop]]
-==&gt;[<span class="key">id</span>:<span class="integer">4</span>,<span class="key">label</span>:person,<span class="key">name</span>:[josh]]
-==&gt;[<span class="key">id</span>:<span class="integer">5</span>,<span class="key">label</span>:software,<span class="key">name</span>:[ripple]]
-==&gt;[<span class="key">id</span>:<span class="integer">6</span>,<span class="key">label</span>:person,<span class="key">name</span>:[peter]]
+==&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]
 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>
@@ -4648,13 +4647,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>))]
 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>))]
 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>))]
-FilterRankingStrategy        [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>))]
 PathRetractionStrategy       [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>))]
-IncidentToAdjacentStrategy   [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>))]
@@ -4750,10 +4749,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)]]})]</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)]], label=[uses]})]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -4971,6 +4970,32 @@ may provide a partial match extension.</
 </div>
 </div>
 <div class="sect2">
+<h3 id="id-step">Id Step</h3>
+<div class="paragraph">
+<p>The <code>id()</code>-step (<strong>map</strong>) takes an <code>Element</code> and extracts its identifier from it.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().id()
+==&gt;<span class="integer">1</span>
+==&gt;<span class="integer">2</span>
+==&gt;<span class="integer">3</span>
+==&gt;<span class="integer">4</span>
+==&gt;<span class="integer">5</span>
+==&gt;<span class="integer">6</span>
+gremlin&gt; g.V(<span class="integer">1</span>).out().id().is(<span class="integer">2</span>)
+==&gt;<span class="integer">2</span>
+gremlin&gt; g.V(<span class="integer">1</span>).outE().id()
+==&gt;<span class="integer">9</span>
+==&gt;<span class="integer">7</span>
+==&gt;<span class="integer">8</span>
+gremlin&gt; g.V(<span class="integer">1</span>).properties().id()
+==&gt;<span class="integer">0</span>
+==&gt;<span class="integer">1</span></code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
 <h3 id="inject-step">Inject Step</h3>
 <div class="imageblock">
 <div class="content">
@@ -5056,6 +5081,54 @@ gremlin&gt; g.V().where(__.in(<span clas
 </div>
 </div>
 <div class="sect2">
+<h3 id="label-step">Label Step</h3>
+<div class="paragraph">
+<p>The <code>label()</code>-step (<strong>map</strong>) takes an <code>Element</code> and extracts its label from it.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().label()
+==&gt;person
+==&gt;person
+==&gt;software
+==&gt;person
+==&gt;software
+==&gt;person
+gremlin&gt; g.V(<span class="integer">1</span>).outE().label()
+==&gt;created
+==&gt;knows
+==&gt;knows
+gremlin&gt; g.V(<span class="integer">1</span>).properties().label()
+==&gt;name
+==&gt;age</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="key-step">Key Step</h3>
+<div class="paragraph">
+<p>The <code>key()</code>-step (<strong>map</strong>) takes a <code>Property</code> and extracts the key from it.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V(<span class="integer">1</span>).properties().key()
+==&gt;name
+==&gt;location
+==&gt;location
+==&gt;location
+==&gt;location
+gremlin&gt; g.V(<span class="integer">1</span>).properties().properties().key()
+==&gt;startTime
+==&gt;endTime
+==&gt;startTime
+==&gt;endTime
+==&gt;startTime
+==&gt;endTime
+==&gt;startTime</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
 <h3 id="limit-step">Limit Step</h3>
 <div class="paragraph">
 <p>The <code>limit()</code>-step is analogous to <a href="#range-step"><code>range()</code>-step</a> save that the lower end range is set to 0.</p>
@@ -5166,6 +5239,20 @@ the confines of the vertex&#8217;s star
 </div>
 </div>
 <div class="sect2">
+<h3 id="loops-step">Loops Step</h3>
+<div class="paragraph">
+<p>The <code>loops()</code>-step (<strong>map</strong>) extracts the number of times the <code>Traverser</code> has gone through the current loop.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().emit(__.has(<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">marko</span><span class="delimiter">&quot;</span></span>).or().loops().is(<span class="integer">2</span>)).repeat(__.out()).values(<span class="string"><span class="delimiter">&quot;</span><span class="content">name</span><span class="delimiter">&quot;</span></span>)
+==&gt;marko
+==&gt;ripple
+==&gt;lop</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
 <h3 id="match-step">Match Step</h3>
 <div class="paragraph">
 <p>The <code>match()</code>-step (<strong>map</strong>) provides a more <a href="http://en.wikipedia.org/wiki/Declarative_programming">declarative</a>
@@ -5262,7 +5349,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(
@@ -5470,7 +5556,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>
@@ -5620,8 +5705,8 @@ not return any objects.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-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">label</span>:software,<span class="key">name</span>:[lop],<span class="key">lang</span>:[java]]
-==&gt;[<span class="key">id</span>:<span class="integer">5</span>,<span class="key">label</span>:software,<span class="key">name</span>:[ripple],<span class="key">lang</span>:[java]]
+==&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]
 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="comment">//</span><b>(1)</b>
 ==&gt;marko
@@ -5809,14 +5894,14 @@ 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">1</span>]
 ==&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>]
 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">6</span>]
 ==&gt;v[<span class="integer">2</span>]
 ==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">6</span>]
 ==&gt;v[<span class="integer">4</span>]</code></pre>
 </div>
 </div>
@@ -5890,11 +5975,11 @@ 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.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.4018125</span>
+==&gt;<span class="float">0.15000000000000002</span>
+==&gt;<span class="float">0.15000000000000002</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().
@@ -5930,28 +6015,28 @@ VertexProgramStrategy           [D]   [T
                                          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]
-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]
-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]
 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]
 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]
 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]
-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]
 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]
 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
+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]
-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
+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]
+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]
+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]
 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]
+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
@@ -6145,19 +6230,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.090</span>     <span class="float">1.85</span>
-VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>           <span class="float">0.116</span>     <span class="float">2.38</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                  <span class="integer">4</span>           <span class="integer">2</span>           <span class="float">0.173</span>     <span class="float">3.55</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">10</span>           <span class="integer">4</span>           <span class="float">3.957</span>    <span class="float">81.03</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">10</span>           <span class="integer">3</span>           <span class="float">0.050</span>     <span class="float">1.03</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">24</span>           <span class="integer">7</span>           <span class="float">0.059</span>     <span class="float">1.23</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">24</span>           <span class="integer">5</span>           <span class="float">0.059</span>     <span class="float">1.22</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">58</span>          <span class="integer">11</span>           <span class="float">0.079</span>     <span class="float">1.62</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">58</span>           <span class="integer">6</span>           <span class="float">0.083</span>     <span class="float">1.72</span>
-HasStep([~label.eq(person)])                                          <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.051</span>     <span class="float">1.05</span>
-PropertiesStep([age],value)                                           <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.057</span>     <span class="float">1.17</span>
-SumGlobalStep                                                          <span class="integer">1</span>           <span class="integer">1</span>           <span class="float">0.104</span>     <span class="float">2.15</span>
-                                            &gt;TOTAL                     -           -           <span class="float">4.883</span>        -</code></pre>
+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">13.28</span>
+VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>           <span class="float">0.100</span>    <span class="float">17.51</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                  <span class="integer">4</span>           <span class="integer">2</span>           <span class="float">0.045</span>     <span class="float">7.88</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">10</span>           <span class="integer">4</span>           <span class="float">0.049</span>     <span class="float">8.60</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">10</span>           <span class="integer">3</span>           <span class="float">0.021</span>     <span class="float">3.70</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">24</span>           <span class="integer">7</span>           <span class="float">0.026</span>     <span class="float">4.59</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">24</span>           <span class="integer">5</span>           <span class="float">0.026</span>     <span class="float">4.56</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">58</span>          <span class="integer">11</span>           <span class="float">0.036</span>     <span class="float">6.39</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">58</span>           <span class="integer">6</span>           <span class="float">0.038</span>     <span class="float">6.71</span>
+HasStep([~label.eq(person)])                                          <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.031</span>     <span class="float">5.53</span>
+PropertiesStep([age],value)                                           <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.034</span>     <span class="float">6.10</span>
+SumGlobalStep                                                          <span class="integer">1</span>           <span class="integer">1</span>           <span class="float">0.086</span>    <span class="float">15.13</span>
+                                            &gt;TOTAL                     -           -           <span class="float">0.571</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6205,10 +6290,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.064</span>    <span class="float">61.62</span>
-VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>          -<span class="float">0.093</span>   -<span class="float">89.26</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                  <span class="integer">4</span>           <span class="integer">2</span>           <span class="float">0.134</span>   <span class="float">127.65</span>
-                                            &gt;TOTAL                     -           -           <span class="float">0.105</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                                             <span class="integer">6</span>           <span class="integer">6</span>           <span class="float">0.265</span>   <span class="float">135.35</span>
+VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>          -<span class="float">0.706</span>  -<span class="float">359.89</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                  <span class="integer">4</span>           <span class="integer">2</span>           <span class="float">0.636</span>   <span class="float">324.54</span>
+                                            &gt;TOTAL                     -           -           <span class="float">0.196</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6373,6 +6458,69 @@ gremlin&gt; g.V().hasLabel(<span class="
 </div>
 </div>
 <div class="sect2">
+<h3 id="_properties_step">Properties Step</h3>
+<div class="paragraph">
+<p>The <code>properties()</code>-step (<strong>map</strong>) extracts properties from an <code>Element</code> in the traversal stream.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V(<span class="integer">1</span>).properties()
+==&gt;vp[name-&gt;marko]
+==&gt;vp[location-&gt;san diego]
+==&gt;vp[location-&gt;santa cruz]
+==&gt;vp[location-&gt;brussels]
+==&gt;vp[location-&gt;santa fe]
+gremlin&gt; g.V(<span class="integer">1</span>).properties(<span class="string"><span class="delimiter">'</span><span class="content">location</span><span class="delimiter">'</span></span>).valueMap()
+==&gt;[<span class="key">startTime</span>:<span class="integer">1997</span>,<span class="key">endTime</span>:<span class="integer">2001</span>]
+==&gt;[<span class="key">startTime</span>:<span class="integer">2001</span>,<span class="key">endTime</span>:<span class="integer">2004</span>]
+==&gt;[<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2005</span>]
+==&gt;[<span class="key">startTime</span>:<span class="integer">2005</span>]
+gremlin&gt; g.V(<span class="integer">1</span>).properties(<span class="string"><span class="delimiter">'</span><span class="content">location</span><span class="delimiter">'</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">endTime</span><span class="delimiter">'</span></span>).valueMap()
+==&gt;[<span class="key">startTime</span>:<span class="integer">1997</span>,<span class="key">endTime</span>:<span class="integer">2001</span>]
+==&gt;[<span class="key">startTime</span>:<span class="integer">2001</span>,<span class="key">endTime</span>:<span class="integer">2004</span>]
+==&gt;[<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2005</span>]</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="propertymap-step">PropertyMap Step</h3>
+<div class="paragraph">
+<p>The <code>propertiesMap()</code>-step yields a Map representation of the properties of an element.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().propertyMap()
+==&gt;[<span class="key">name</span>:[vp[name-&gt;marko]],<span class="key">age</span>:[vp[age-&gt;<span class="integer">29</span>]]]
+==&gt;[<span class="key">name</span>:[vp[name-&gt;vadas]],<span class="key">age</span>:[vp[age-&gt;<span class="integer">27</span>]]]
+==&gt;[<span class="key">name</span>:[vp[name-&gt;lop]],<span class="key">lang</span>:[vp[lang-&gt;java]]]
+==&gt;[<span class="key">name</span>:[vp[name-&gt;josh]],<span class="key">age</span>:[vp[age-&gt;<span class="integer">32</span>]]]
+==&gt;[<span class="key">name</span>:[vp[name-&gt;ripple]],<span class="key">lang</span>:[vp[lang-&gt;java]]]
+==&gt;[<span class="key">name</span>:[vp[name-&gt;peter]],<span class="key">age</span>:[vp[age-&gt;<span class="integer">35</span>]]]
+gremlin&gt; g.V().propertyMap(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>)
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">29</span>]]]
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">27</span>]]]
+==&gt;<span class="type">[]</span>
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">32</span>]]]
+==&gt;<span class="type">[]</span>
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">35</span>]]]
+gremlin&gt; g.V().propertyMap(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">blah</span><span class="delimiter">'</span></span>)
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">29</span>]]]
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">27</span>]]]
+==&gt;<span class="type">[]</span>
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">32</span>]]]
+==&gt;<span class="type">[]</span>
+==&gt;[<span class="key">age</span>:[vp[age-&gt;<span class="integer">35</span>]]]
+gremlin&gt; g.E().propertyMap()
+==&gt;[<span class="key">weight</span>:p[weight-&gt;<span class="float">0.5</span>]]
+==&gt;[<span class="key">weight</span>:p[weight-&gt;<span class="float">1.0</span>]]
+==&gt;[<span class="key">weight</span>:p[weight-&gt;<span class="float">0.4</span>]]
+==&gt;[<span class="key">weight</span>:p[weight-&gt;<span class="float">1.0</span>]]
+==&gt;[<span class="key">weight</span>:p[weight-&gt;<span class="float">0.4</span>]]
+==&gt;[<span class="key">weight</span>:p[weight-&gt;<span class="float">0.2</span>]]</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
 <h3 id="range-step">Range Step</h3>
 <div class="paragraph">
 <p>As traversers propagate through the traversal, it is possible to only allow a certain number of them to pass through
@@ -6634,14 +6782,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">3f</span>f83cc8
+==&gt;java.util.Random<span class="error">@</span><span class="float">5e79</span>bdf6
 gremlin&gt; g.withSack {rand.nextFloat()}.V().sack()
-==&gt;<span class="float">0.13132292</span>
-==&gt;<span class="float">0.18358696</span>
-==&gt;<span class="float">0.38874727</span>
-==&gt;<span class="float">0.4139933</span>
-==&gt;<span class="float">0.8642254</span>
-==&gt;<span class="float">0.5374192</span></code></pre>
+==&gt;<span class="float">0.8159547</span>
+==&gt;<span class="float">0.6531751</span>
+==&gt;<span class="float">0.8909631</span>
+==&gt;<span class="float">0.9029786</span>
+==&gt;<span class="float">0.31527013</span>
+==&gt;<span class="float">0.050559044</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6752,12 +6900,12 @@ 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">0.4</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">0.4</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">1.0</span>
-==&gt;<span class="float">0.4</span></code></pre>
+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>
 </div>
 </div>
 <div class="paragraph">
@@ -6772,15 +6920,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">3</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">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">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">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>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span class="integer">2</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">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>],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="in
 teger">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="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>]]</code></pre>
+==&gt;[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">9</span>][<span class="integer">1</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">9</span>][<span class="integer">1</span>-created-&gt;<span class="integer">3</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>],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>]]</code></pre>
 </div>
 </div>
 </div>
@@ -6878,7 +7026,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>).
@@ -6902,7 +7049,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>
@@ -6939,6 +7085,22 @@ Note that <code>by()</code>-modulation i
 </tr>
 </table>
 </div>
+<div class="paragraph">
+<p>There is also an option to supply a <code>Pop</code> operation to <code>select()</code> to manipulate <code>List</code> objects in the <code>Traverser</code>:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V(<span class="integer">1</span>).as(<span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>).repeat(out().as(<span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>)).times(<span class="integer">2</span>).select(first, <span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">1</span>]
+gremlin&gt; g.V(<span class="integer">1</span>).as(<span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>).repeat(out().as(<span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>)).times(<span class="integer">2</span>).select(last, <span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">5</span>]
+==&gt;v[<span class="integer">3</span>]
+gremlin&gt; g.V(<span class="integer">1</span>).as(<span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>).repeat(out().as(<span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>)).times(<span class="integer">2</span>).select(all, <span class="string"><span class="delimiter">&quot;</span><span class="content">a</span><span class="delimiter">&quot;</span></span>)
+==&gt;[v[<span class="integer">1</span>],v[<span class="integer">4</span>],v[<span class="integer">5</span>]]
+==&gt;[v[<span class="integer">1</span>],v[<span class="integer">4</span>],v[<span class="integer">3</span>]]</code></pre>
+</div>
+</div>
 <div class="sect3">
 <h4 id="using-where-with-select">Using Where with Select</h4>
 <div class="paragraph">
@@ -7008,12 +7170,12 @@ objects in it, the traverser is filtered
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V(<span class="integer">1</span>).both().both()
 ==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">1</span>]
-==&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">5</span>]
 ==&gt;v[<span class="integer">3</span>]
+==&gt;v[<span class="integer">1</span>]
 gremlin&gt; g.V(<span class="integer">1</span>).both().both().simplePath()
 ==&gt;v[<span class="integer">4</span>]
 ==&gt;v[<span class="integer">6</span>]
@@ -7291,7 +7453,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">1.115165</span>
+==&gt;<span class="float">1.734138</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>
@@ -7300,7 +7462,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">3.132507</span></code></pre>
+==&gt;<span class="float">1.596263</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -7429,6 +7591,30 @@ gremlin&gt; g.V(<span class="integer">4<
 </div>
 </div>
 <div class="sect2">
+<h3 id="value-step">Value Step</h3>
+<div class="paragraph">
+<p>The <code>value()</code>-step (<strong>map</strong>) takes a <code>Property</code> and extracts the value from it.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V(<span class="integer">1</span>).properties().value()
+==&gt;marko
+==&gt;san diego
+==&gt;santa cruz
+==&gt;brussels
+==&gt;santa fe
+gremlin&gt; g.V(<span class="integer">1</span>).properties().properties().value()
+==&gt;<span class="integer">1997</span>
+==&gt;<span class="integer">2001</span>
+==&gt;<span class="integer">2001</span>
+==&gt;<span class="integer">2004</span>
+==&gt;<span class="integer">2004</span>
+==&gt;<span class="integer">2005</span>
+==&gt;<span class="integer">2005</span></code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
 <h3 id="valuemap-step">ValueMap Step</h3>
 <div class="paragraph">
 <p>The <code>valueMap()</code>-step yields a Map representation of the properties of an element.</p>
@@ -7498,30 +7684,59 @@ 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">id</span>:<span class="integer">1</span>,<span class="key">label</span>:person,<span class="key">name</span>:[marko],<span class="key">location</span>:[san diego,santa cruz,brussels,santa fe]]
-==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span class="key">label</span>:person,<span class="key">name</span>:[stephen],<span class="key">location</span>:[centreville,dulles,purcellville]]
-==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span class="key">label</span>:person,<span class="key">name</span>:[matthias],<span class="key">location</span>:[bremen,baltimore,oakland,seattle]]
-==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">label</span>:person,<span class="key">name</span>:[daniel],<span class="key">location</span>:[spremberg,kaiserslautern,aachen]]
+==&gt;[<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],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span class="key">name</span>:[stephen],<span class="key">location</span>:[centreville,dulles,purcellville],<span class="key">label</span>:person]
+==&gt;[<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],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">name</span>:[daniel],<span class="key">location</span>:[spremberg,kaiserslautern,aachen],<span class="key">label</span>:person]
 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">id</span>:<span class="integer">1</span>,<span class="key">label</span>:person,<span class="key">name</span>:[marko]]
-==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span class="key">label</span>:person,<span class="key">name</span>:[stephen]]
-==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span class="key">label</span>:person,<span class="key">name</span>:[matthias]]
-==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">label</span>:person,<span class="key">name</span>:[daniel]]

[... 1100 lines stripped ...]


Mime
View raw message