Modified: tinkerpop/site/docs/3.2.4/recipes/index.html
URL: 
http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.4/recipes/index.html?rev=1782133&r1=1782132&r2=1782133&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.4/recipes/index.html (original)
+++ tinkerpop/site/docs/3.2.4/recipes/index.html Wed Feb  8 09:34:04 2017
@@ -878,14 +878,23 @@ traversal on the paths found between the
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V(1).bothE()                                   <b>(1)</b>
-g.V(1).bothE().where(otherV().hasId(2))          <b>(2)</b>
-v1 = g.V(1).next();[]
-v2 = g.V(2).next();[]
-g.V(v1).bothE().where(otherV().is(v2))           <b>(3)</b>
-g.V(v1).outE().where(inV().is(v2))               <b>(4)</b>
-g.V(1).outE().where(inV().has(id, within(2,3)))  <b>(5)</b>
-g.V(1).out().where(__.in().hasId(6))             <b>(6)</b></pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V(<span class="integer">1</span>).bothE() <span 
class="comment">//</span><b>(1)</b>
+==&gt;e[<span class="integer">9</span>][<span 
class="integer">1</span>-created-&gt;<span class="integer">3</span>]
+==&gt;e[<span class="integer">7</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">2</span>]
+==&gt;e[<span class="integer">8</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">4</span>]
+gremlin&gt; g.V(<span 
class="integer">1</span>).bothE().where(otherV().hasId(<span 
class="integer">2</span>)) <span class="comment">//</span><b>(2)</b>
+==&gt;e[<span class="integer">7</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">2</span>]
+gremlin&gt; v1 = g.V(<span class="integer">1</span>).next();<span 
class="type">[]</span>
+gremlin&gt; v2 = g.V(<span class="integer">2</span>).next();<span 
class="type">[]</span>
+gremlin&gt; g.V(v1).bothE().where(otherV().is(v2)) <span 
class="comment">//</span><b>(3)</b>
+==&gt;e[<span class="integer">7</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">2</span>]
+gremlin&gt; g.V(v1).outE().where(inV().is(v2)) <span 
class="comment">//</span><b>(4)</b>
+==&gt;e[<span class="integer">7</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">2</span>]
+gremlin&gt; g.V(<span class="integer">1</span>).outE().where(inV().has(id, 
within(<span class="integer">2</span>,<span class="integer">3</span>))) <span 
class="comment">//</span><b>(5)</b>
+==&gt;e[<span class="integer">9</span>][<span 
class="integer">1</span>-created-&gt;<span class="integer">3</span>]
+==&gt;e[<span class="integer">7</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">2</span>]
+gremlin&gt; g.V(<span 
class="integer">1</span>).out().where(__.in().hasId(<span 
class="integer">6</span>)) <span class="comment">//</span><b>(6)</b>
+==&gt;v[<span class="integer">3</span>]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -921,11 +930,20 @@ vertices:</p>
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>ids = [2,4,6].toArray()
-g.V(ids).as("a").
-  
repeat(bothE().otherV().simplePath()).times(5).emit(hasId(within(ids))).as("b").
-  filter(select(last,"a","b").by(id).where("a", lt("b"))).
-  path().by().by(label)</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; ids = 
[<span class="integer">2</span>,<span class="integer">4</span>,<span 
class="integer">6</span>].toArray()
+==&gt;<span class="integer">2</span>
+==&gt;<span class="integer">4</span>
+==&gt;<span class="integer">6</span>
+gremlin&gt; g.V(ids).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>).
+           repeat(bothE().otherV().simplePath()).times(<span 
class="integer">5</span>).emit(hasId(within(ids))).as(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">b</span><span class="delimiter">&quot;</span></span>).
+           filter(select(last,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">b</span><span 
class="delimiter">&quot;</span></span>).by(id).where(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>, lt(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">b</span><span 
class="delimiter">&quot;</span></span>))).
+           path().by().by(label)
+==&gt;[v[<span class="integer">2</span>],knows,v[<span 
class="integer">1</span>],knows,v[<span class="integer">4</span>]]
+==&gt;[v[<span class="integer">2</span>],knows,v[<span 
class="integer">1</span>],created,v[<span 
class="integer">3</span>],created,v[<span class="integer">4</span>]]
+==&gt;[v[<span class="integer">2</span>],knows,v[<span 
class="integer">1</span>],created,v[<span 
class="integer">3</span>],created,v[<span class="integer">6</span>]]
+==&gt;[v[<span class="integer">2</span>],knows,v[<span 
class="integer">1</span>],knows,v[<span 
class="integer">4</span>],created,v[<span 
class="integer">3</span>],created,v[<span class="integer">6</span>]]
+==&gt;[v[<span class="integer">4</span>],created,v[<span 
class="integer">3</span>],created,v[<span class="integer">6</span>]]
+==&gt;[v[<span class="integer">4</span>],knows,v[<span 
class="integer">1</span>],created,v[<span 
class="integer">3</span>],created,v[<span 
class="integer">6</span>]]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -941,46 +959,73 @@ the known person completed an applicatio
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>vBob = graph.addVertex(label, "person", "name", "bob")
-vStephen = graph.addVertex(label, "person", "name", "stephen")
-vBlueprintsInc = graph.addVertex(label, "company", "name", "Blueprints, Inc")
-vRexsterLlc = graph.addVertex(label, "company", "name", "Rexster, LLC")
-vBlueprintsJob1 = graph.addVertex(label, "job", "name", "job1")
-vBlueprintsJob2 = graph.addVertex(label, "job", "name", "job2")
-vBlueprintsJob3 = graph.addVertex(label, "job", "name", "job3")
-vRexsterJob1 = graph.addVertex(label, "job", "name", "job4")
-vAppBob1 = graph.addVertex(label, "application", "name", "application1")
-vAppBob2 = graph.addVertex(label, "application", "name", "application2")
-vAppStephen1 = graph.addVertex(label, "application", "name", "application3")
-vAppStephen2 = graph.addVertex(label, "application", "name", "application4")
-vBob.addEdge("completes", vAppBob1)
-vBob.addEdge("completes", vAppBob2)
-vStephen.addEdge("completes", vAppStephen1)
-vStephen.addEdge("completes", vAppStephen2)
-vAppBob1.addEdge("appliesTo", vBlueprintsJob1)
-vAppBob2.addEdge("appliesTo", vBlueprintsJob2)
-vAppStephen1.addEdge("appliesTo", vRexsterJob1)
-vAppStephen2.addEdge("appliesTo", vBlueprintsJob3)
-vBlueprintsInc.addEdge("created", vBlueprintsJob1, "creationDate", 
"12/20/2015")
-vBlueprintsInc.addEdge("created", vBlueprintsJob2, "creationDate", 
"12/15/2015")
-vBlueprintsInc.addEdge("created", vBlueprintsJob3, "creationDate", 
"12/16/2015")
-vRexsterLlc.addEdge("created", vRexsterJob1, "creationDate", "12/18/2015")
-g.V(vRexsterJob1).as('job').
-  inE('created').as('created').
-  outV().as('company').
-  select('job').
-  coalesce(__.in('appliesTo').where(__.in('completes').is(vStephen)),
-           constant(false)).as('application').
-  select('job', 'company', 'created', 'application').
-    by().by().by('creationDate').by()
-g.V(vRexsterJob1, vBlueprintsJob1).as('job').
-  inE('created').as('created').
-  outV().as('company').
-  select('job').
-  coalesce(__.in('appliesTo').where(__.in('completes').is(vBob)),
-           constant(false)).as('application').
-  select('job', 'company', 'created', 'application').
-    by().by().by('creationDate').by()</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; vBob = 
graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">person</span><span 
class="delimiter">&quot;</span></span>, <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">bob</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">0</span>]
+gremlin&gt; vStephen = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">person</span><span 
class="delimiter">&quot;</span></span>, <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">stephen</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">2</span>]
+gremlin&gt; vBlueprintsInc = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">company</span><span 
class="delimiter">&quot;</span></span>, <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">Blueprints, 
Inc</span><span class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">4</span>]
+gremlin&gt; vRexsterLlc = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">company</span><span 
class="delimiter">&quot;</span></span>, <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">Rexster, LLC</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">6</span>]
+gremlin&gt; vBlueprintsJob1 = graph.addVertex(label, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">job</span><span class="delimiter">&quot;</span></span>, <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">job1</span><span class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">8</span>]
+gremlin&gt; vBlueprintsJob2 = graph.addVertex(label, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">job</span><span class="delimiter">&quot;</span></span>, <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">job2</span><span class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">10</span>]
+gremlin&gt; vBlueprintsJob3 = graph.addVertex(label, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">job</span><span class="delimiter">&quot;</span></span>, <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">job3</span><span class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">12</span>]
+gremlin&gt; vRexsterJob1 = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">job</span><span 
class="delimiter">&quot;</span></span>, <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">job4</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">14</span>]
+gremlin&gt; vAppBob1 = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">application</span><span 
class="delimiter">&quot;</span></span>, <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">application1</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">16</span>]
+gremlin&gt; vAppBob2 = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">application</span><span 
class="delimiter">&quot;</span></span>, <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">application2</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">18</span>]
+gremlin&gt; vAppStephen1 = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">application</span><span 
class="delimiter">&quot;</span></span>, <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">application3</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">20</span>]
+gremlin&gt; vAppStephen2 = graph.addVertex(label, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">application</span><span 
class="delimiter">&quot;</span></span>, <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">application4</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;v[<span class="integer">22</span>]
+gremlin&gt; vBob.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">completes</span><span 
class="delimiter">&quot;</span></span>, vAppBob1)
+==&gt;e[<span class="integer">24</span>][<span 
class="integer">0</span>-completes-&gt;<span class="integer">16</span>]
+gremlin&gt; vBob.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">completes</span><span 
class="delimiter">&quot;</span></span>, vAppBob2)
+==&gt;e[<span class="integer">25</span>][<span 
class="integer">0</span>-completes-&gt;<span class="integer">18</span>]
+gremlin&gt; vStephen.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">completes</span><span 
class="delimiter">&quot;</span></span>, vAppStephen1)
+==&gt;e[<span class="integer">26</span>][<span 
class="integer">2</span>-completes-&gt;<span class="integer">20</span>]
+gremlin&gt; vStephen.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">completes</span><span 
class="delimiter">&quot;</span></span>, vAppStephen2)
+==&gt;e[<span class="integer">27</span>][<span 
class="integer">2</span>-completes-&gt;<span class="integer">22</span>]
+gremlin&gt; vAppBob1.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">appliesTo</span><span 
class="delimiter">&quot;</span></span>, vBlueprintsJob1)
+==&gt;e[<span class="integer">28</span>][<span 
class="integer">16</span>-appliesTo-&gt;<span class="integer">8</span>]
+gremlin&gt; vAppBob2.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">appliesTo</span><span 
class="delimiter">&quot;</span></span>, vBlueprintsJob2)
+==&gt;e[<span class="integer">29</span>][<span 
class="integer">18</span>-appliesTo-&gt;<span class="integer">10</span>]
+gremlin&gt; vAppStephen1.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">appliesTo</span><span 
class="delimiter">&quot;</span></span>, vRexsterJob1)
+==&gt;e[<span class="integer">30</span>][<span 
class="integer">20</span>-appliesTo-&gt;<span class="integer">14</span>]
+gremlin&gt; vAppStephen2.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">appliesTo</span><span 
class="delimiter">&quot;</span></span>, vBlueprintsJob3)
+==&gt;e[<span class="integer">31</span>][<span 
class="integer">22</span>-appliesTo-&gt;<span class="integer">12</span>]
+gremlin&gt; vBlueprintsInc.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">created</span><span 
class="delimiter">&quot;</span></span>, vBlueprintsJob1, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">creationDate</span><span 
class="delimiter">&quot;</span></span>, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">12/20/2015</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;e[<span class="integer">32</span>][<span 
class="integer">4</span>-created-&gt;<span class="integer">8</span>]
+gremlin&gt; vBlueprintsInc.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">created</span><span 
class="delimiter">&quot;</span></span>, vBlueprintsJob2, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">creationDate</span><span 
class="delimiter">&quot;</span></span>, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">12/15/2015</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;e[<span class="integer">33</span>][<span 
class="integer">4</span>-created-&gt;<span class="integer">10</span>]
+gremlin&gt; vBlueprintsInc.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">created</span><span 
class="delimiter">&quot;</span></span>, vBlueprintsJob3, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">creationDate</span><span 
class="delimiter">&quot;</span></span>, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">12/16/2015</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;e[<span class="integer">34</span>][<span 
class="integer">4</span>-created-&gt;<span class="integer">12</span>]
+gremlin&gt; vRexsterLlc.addEdge(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">created</span><span 
class="delimiter">&quot;</span></span>, vRexsterJob1, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">creationDate</span><span 
class="delimiter">&quot;</span></span>, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">12/18/2015</span><span 
class="delimiter">&quot;</span></span>)
+==&gt;e[<span class="integer">35</span>][<span 
class="integer">6</span>-created-&gt;<span class="integer">14</span>]
+gremlin&gt; g.V(vRexsterJob1).as(<span class="string"><span 
class="delimiter">'</span><span class="content">job</span><span 
class="delimiter">'</span></span>).
+           inE(<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">created</span><span class="delimiter">'</span></span>).
+           outV().as(<span class="string"><span 
class="delimiter">'</span><span class="content">company</span><span 
class="delimiter">'</span></span>).
+           select(<span class="string"><span class="delimiter">'</span><span 
class="content">job</span><span class="delimiter">'</span></span>).
+           coalesce(__.in(<span class="string"><span 
class="delimiter">'</span><span class="content">appliesTo</span><span 
class="delimiter">'</span></span>).where(__.in(<span class="string"><span 
class="delimiter">'</span><span class="content">completes</span><span 
class="delimiter">'</span></span>).is(vStephen)),
+                    constant(<span 
class="predefined-constant">false</span>)).as(<span class="string"><span 
class="delimiter">'</span><span class="content">application</span><span 
class="delimiter">'</span></span>).
+           select(<span class="string"><span class="delimiter">'</span><span 
class="content">job</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">company</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">created</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">application</span><span class="delimiter">'</span></span>).
+             by().by().by(<span class="string"><span 
class="delimiter">'</span><span class="content">creationDate</span><span 
class="delimiter">'</span></span>).by()
+==&gt;[<span class="key">job</span>:v[<span class="integer">14</span>],<span 
class="key">company</span>:v[<span class="integer">6</span>],<span 
class="key">created</span>:<span class="integer">12</span>/<span 
class="integer">18</span>/<span class="integer">2015</span>,<span 
class="key">application</span>:v[<span class="integer">20</span>]]
+gremlin&gt; g.V(vRexsterJob1, vBlueprintsJob1).as(<span class="string"><span 
class="delimiter">'</span><span class="content">job</span><span 
class="delimiter">'</span></span>).
+           inE(<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">created</span><span class="delimiter">'</span></span>).
+           outV().as(<span class="string"><span 
class="delimiter">'</span><span class="content">company</span><span 
class="delimiter">'</span></span>).
+           select(<span class="string"><span class="delimiter">'</span><span 
class="content">job</span><span class="delimiter">'</span></span>).
+           coalesce(__.in(<span class="string"><span 
class="delimiter">'</span><span class="content">appliesTo</span><span 
class="delimiter">'</span></span>).where(__.in(<span class="string"><span 
class="delimiter">'</span><span class="content">completes</span><span 
class="delimiter">'</span></span>).is(vBob)),
+                    constant(<span 
class="predefined-constant">false</span>)).as(<span class="string"><span 
class="delimiter">'</span><span class="content">application</span><span 
class="delimiter">'</span></span>).
+           select(<span class="string"><span class="delimiter">'</span><span 
class="content">job</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">company</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">created</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">application</span><span class="delimiter">'</span></span>).
+             by().by().by(<span class="string"><span 
class="delimiter">'</span><span class="content">creationDate</span><span 
class="delimiter">'</span></span>).by()
+==&gt;[<span class="key">job</span>:v[<span class="integer">14</span>],<span 
class="key">company</span>:v[<span class="integer">6</span>],<span 
class="key">created</span>:<span class="integer">12</span>/<span 
class="integer">18</span>/<span class="integer">2015</span>,<span 
class="key">application</span>:<span class="predefined-constant">false</span>]
+==&gt;[<span class="key">job</span>:v[<span class="integer">8</span>],<span 
class="key">company</span>:v[<span class="integer">4</span>],<span 
class="key">created</span>:<span class="integer">12</span>/<span 
class="integer">20</span>/<span class="integer">2015</span>,<span 
class="key">application</span>:v[<span class="integer">16</span>]]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1007,13 +1052,26 @@ edges associated to each vertex. The fol
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V().group().by().by(bothE().count())                <b>(1)</b>
-g.V().group().by().by(inE().count())                  <b>(2)</b>
-g.V().group().by().by(outE().count())                 <b>(3)</b>
-g.V().project("v","degree").by().by(bothE().count())  <b>(4)</b>
-g.V().project("v","degree").by().by(bothE().count()). <b>(5)</b>
-  order().by(select("degree"), decr).
-  limit(4)</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().group().by().by(bothE().count()) <span class="comment">//</span><b>(1)</b>
+==&gt;[v[<span class="integer">1</span>]:<span 
class="integer">3</span>,v[<span class="integer">2</span>]:<span 
class="integer">1</span>,v[<span class="integer">3</span>]:<span 
class="integer">3</span>,v[<span class="integer">4</span>]:<span 
class="integer">3</span>,v[<span class="integer">5</span>]:<span 
class="integer">1</span>,v[<span class="integer">6</span>]:<span 
class="integer">1</span>]
+gremlin&gt; g.V().group().by().by(inE().count()) <span 
class="comment">//</span><b>(2)</b>
+==&gt;[v[<span class="integer">1</span>]:<span 
class="integer">0</span>,v[<span class="integer">2</span>]:<span 
class="integer">1</span>,v[<span class="integer">3</span>]:<span 
class="integer">3</span>,v[<span class="integer">4</span>]:<span 
class="integer">1</span>,v[<span class="integer">5</span>]:<span 
class="integer">1</span>,v[<span class="integer">6</span>]:<span 
class="integer">0</span>]
+gremlin&gt; g.V().group().by().by(outE().count()) <span 
class="comment">//</span><b>(3)</b>
+==&gt;[v[<span class="integer">1</span>]:<span 
class="integer">3</span>,v[<span class="integer">2</span>]:<span 
class="integer">0</span>,v[<span class="integer">3</span>]:<span 
class="integer">0</span>,v[<span class="integer">4</span>]:<span 
class="integer">2</span>,v[<span class="integer">5</span>]:<span 
class="integer">0</span>,v[<span class="integer">6</span>]:<span 
class="integer">1</span>]
+gremlin&gt; g.V().project(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">degree</span><span 
class="delimiter">&quot;</span></span>).by().by(bothE().count()) <span 
class="comment">//</span><b>(4)</b>
+==&gt;[<span class="key">v</span>:v[<span class="integer">1</span>],<span 
class="key">degree</span>:<span class="integer">3</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">2</span>],<span 
class="key">degree</span>:<span class="integer">1</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">3</span>],<span 
class="key">degree</span>:<span class="integer">3</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">4</span>],<span 
class="key">degree</span>:<span class="integer">3</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">5</span>],<span 
class="key">degree</span>:<span class="integer">1</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">6</span>],<span 
class="key">degree</span>:<span class="integer">1</span>]
+gremlin&gt; g.V().project(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">degree</span><span 
class="delimiter">&quot;</span></span>).by().by(bothE().count()). <span 
class="comment">//</span><b>(5)</b>
+           order().by(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">degree</span><span 
class="delimiter">&quot;</span></span>), decr).
+           limit(<span class="integer">4</span>)
+==&gt;[<span class="key">v</span>:v[<span class="integer">1</span>],<span 
class="key">degree</span>:<span class="integer">3</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">3</span>],<span 
class="key">degree</span>:<span class="integer">3</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">4</span>],<span 
class="key">degree</span>:<span class="integer">3</span>]
+==&gt;[<span class="key">v</span>:v[<span class="integer">2</span>],<span 
class="key">degree</span>:<span class="integer">1</span>]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1067,32 +1125,38 @@ graph for demonstration purposes:</p>
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.addV(id,'A').as('a').
-  addV(id,'B').as('b').
-  addV(id,'C').as('c').
-  addV(id,'D').as('d').
-  addV(id,'E').as('e').
-  addV(id,'F').as('f').
-  addE('next').from('a').to('b').
-  addE('next').from('b').to('c').
-  addE('next').from('b').to('d').
-  addE('next').from('c').to('e').
-  addE('next').from('d').to('e').
-  addE('next').from('e').to('f').iterate()
-g.V().as("v").                                                                 
 <b>(1)</b>
-  repeat(both().simplePath().as("v")).emit().                                  
 <b>(2)</b>
-  filter(project("x","y","z").by(select(first, "v")).                          
 <b>(3)</b>
-                              by(select(last, "v")).
-                              by(select(all, "v").count(local)).as("triple").
-         coalesce(select("x","y").as("a").                                     
 <b>(4)</b>
-                    select("triples").unfold().as("t").
-                    select("x","y").where(eq("a")).
-                    select("t"),
-                  store("triples")).                                           
 <b>(5)</b>
-         select("z").as("length").
-         select("triple").select("z").where(eq("length"))).                    
 <b>(6)</b>
-  select(all, "v").unfold().                                                   
 <b>(7)</b>
-  groupCount().next()                                                          
 <b>(8)</b></pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">A</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">a</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">B</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">C</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">D</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">d</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">E</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">e</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">F</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">f</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">next</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">a</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">next</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">next</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">d</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">next</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">e</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">next</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">d</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">e</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">next</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">e</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">f</span><span class="delimiter">'</span></span>).iterate()
+gremlin&gt; g.V().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(1)</b>
+           repeat(both().simplePath().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>)).emit(). <span 
class="comment">//</span><b>(2)</b>
+           filter(project(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">x</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">y</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">z</span><span 
class="delimiter">&quot;</span></span>).by(select(first, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">v</span><span class="delimiter">&quot;</span></span>)). <span 
class="comment">//</span><b>(3)</b>
+                                       by(select(last, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">v</span><span class="delimiter">&quot;</span></span>)).
+                                       by(select(all, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">v</span><span 
class="delimiter">&quot;</span></span>).count(local)).as(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">triple</span><span class="delimiter">&quot;</span></span>).
+                  coalesce(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">x</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">y</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(4)</b>
+                             select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">triples</span><span 
class="delimiter">&quot;</span></span>).unfold().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">t</span><span 
class="delimiter">&quot;</span></span>).
+                             select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">x</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">y</span><span 
class="delimiter">&quot;</span></span>).where(eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>)).
+                             select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">t</span><span 
class="delimiter">&quot;</span></span>),
+                           store(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">triples</span><span 
class="delimiter">&quot;</span></span>)). <span 
class="comment">//</span><b>(5)</b>
+                  select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">z</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">length</span><span 
class="delimiter">&quot;</span></span>).
+                  select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">triple</span><span 
class="delimiter">&quot;</span></span>).select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">z</span><span 
class="delimiter">&quot;</span></span>).where(eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">length</span><span 
class="delimiter">&quot;</span></span>))). <span 
class="comment">//</span><b>(6)</b>
+           select(all, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>).unfold(). <span 
class="comment">//</span><b>(7)</b>
+           groupCount().next() <span class="comment">//</span><b>(8)</b>
+==&gt;v[A]=<span class="integer">14</span>
+==&gt;v[B]=<span class="integer">28</span>
+==&gt;v[C]=<span class="integer">20</span>
+==&gt;v[D]=<span class="integer">20</span>
+==&gt;v[E]=<span class="integer">28</span>
+==&gt;v[F]=<span class="integer">14</span></code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1148,21 +1212,28 @@ other reachable vertices in the graph. T
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g = TinkerFactory.createModern().traversal()
-g.withSack(1f).V().as("v").                                                    
 <b>(1)</b>
-  repeat(both().simplePath().as("v")).emit().                                  
 <b>(2)</b>
-  filter(project("x","y","z").by(select(first, "v")).                          
 <b>(3)</b>
-                              by(select(last, "v")).
-                              by(select(all, "v").count(local)).as("triple").
-         coalesce(select("x","y").as("a").                                     
 <b>(4)</b>
-                    select("triples").unfold().as("t").
-                    select("x","y").where(eq("a")).
-                    select("t"),
-                  store("triples")).                                           
 <b>(5)</b>
-         select("z").as("length").
-         select("triple").select("z").where(eq("length"))).                    
 <b>(6)</b>
-  group().by(select(first, "v")).                                              
 <b>(7)</b>
-          by(select(all, "v").count(local).sack(div).sack().sum()).next()</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g = 
TinkerFactory.createModern().traversal()
+==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">6</span> <span class="key">edges</span>:<span 
class="integer">6</span>], standard]
+gremlin&gt; g.withSack(<span class="float">1f</span>).V().as(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">v</span><span class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(1)</b>
+           repeat(both().simplePath().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>)).emit(). <span 
class="comment">//</span><b>(2)</b>
+           filter(project(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">x</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">y</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">z</span><span 
class="delimiter">&quot;</span></span>).by(select(first, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">v</span><span class="delimiter">&quot;</span></span>)). <span 
class="comment">//</span><b>(3)</b>
+                                       by(select(last, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">v</span><span class="delimiter">&quot;</span></span>)).
+                                       by(select(all, <span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">v</span><span 
class="delimiter">&quot;</span></span>).count(local)).as(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">triple</span><span class="delimiter">&quot;</span></span>).
+                  coalesce(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">x</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">y</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(4)</b>
+                             select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">triples</span><span 
class="delimiter">&quot;</span></span>).unfold().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">t</span><span 
class="delimiter">&quot;</span></span>).
+                             select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">x</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">y</span><span 
class="delimiter">&quot;</span></span>).where(eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>)).
+                             select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">t</span><span 
class="delimiter">&quot;</span></span>),
+                           store(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">triples</span><span 
class="delimiter">&quot;</span></span>)). <span 
class="comment">//</span><b>(5)</b>
+                  select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">z</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">length</span><span 
class="delimiter">&quot;</span></span>).
+                  select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">triple</span><span 
class="delimiter">&quot;</span></span>).select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">z</span><span 
class="delimiter">&quot;</span></span>).where(eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">length</span><span 
class="delimiter">&quot;</span></span>))). <span 
class="comment">//</span><b>(6)</b>
+           group().by(select(first, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>)). <span 
class="comment">//</span><b>(7)</b>
+                   by(select(all, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>).count(local).sack(div).sack().sum()).next()
+==&gt;v[<span class="integer">1</span>]=<span 
class="float">2.1666666666666665</span>
+==&gt;v[<span class="integer">2</span>]=<span 
class="float">1.6666666666666665</span>
+==&gt;v[<span class="integer">3</span>]=<span 
class="float">2.1666666666666665</span>
+==&gt;v[<span class="integer">4</span>]=<span 
class="float">2.1666666666666665</span>
+==&gt;v[<span class="integer">5</span>]=<span 
class="float">1.6666666666666665</span>
+==&gt;v[<span class="integer">6</span>]=<span 
class="float">1.6666666666666665</span></code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1217,11 +1288,32 @@ give it the highest rank. Consider the f
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>graph.io(graphml()).readGraph('data/grateful-dead.xml')
-g.V().repeat(groupCount('m').by('name').out()).times(5).cap('m').              
  <b>(1)</b>
-  order(local).by(values, decr).limit(local, 10).next()                        
  <b>(2)</b>
-g.V().repeat(groupCount('m').by('name').out().timeLimit(100)).times(5).cap('m').
 <b>(3)</b>
-  order(local).by(values, decr).limit(local, 10).next()</pre>
+<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.V().repeat(groupCount(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).by(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>).out()).times(<span 
class="integer">5</span>).cap(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>). <span class="comment">//</span><b>(1)</b>
+           order(local).by(values, decr).limit(local, <span 
class="integer">10</span>).next() <span class="comment">//</span><b>(2)</b>
+==&gt;PLAYING IN THE BAND=<span class="integer">8758598</span>
+==&gt;ME AND MY UNCLE=<span class="integer">8214246</span>
+==&gt;JACK STRAW=<span class="integer">8173882</span>
+==&gt;EL PASO=<span class="integer">7666994</span>
+==&gt;TRUCKING=<span class="integer">7643494</span>
+==&gt;PROMISED LAND=<span class="integer">7339027</span>
+==&gt;CHINA CAT SUNFLOWER=<span class="integer">7322213</span>
+==&gt;CUMBERLAND BLUES=<span class="integer">6730838</span>
+==&gt;RAMBLE ON ROSE=<span class="integer">6676667</span>
+==&gt;LOOKS LIKE RAIN=<span class="integer">6674121</span>
+gremlin&gt; g.V().repeat(groupCount(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).by(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>).out().timeLimit(<span 
class="integer">100</span>)).times(<span class="integer">5</span>).cap(<span 
class="string"><span class="delimiter">'</span><span 
class="content">m</span><span class="delimiter">'</span></span>). <span 
class="comment">//</span><b>(3)</b>
+           order(local).by(values, decr).limit(local, <span 
class="integer">10</span>).next()
+==&gt;PLAYING IN THE BAND=<span class="integer">8758598</span>
+==&gt;ME AND MY UNCLE=<span class="integer">8214246</span>
+==&gt;JACK STRAW=<span class="integer">8173882</span>
+==&gt;EL PASO=<span class="integer">7666994</span>
+==&gt;TRUCKING=<span class="integer">7643494</span>
+==&gt;PROMISED LAND=<span class="integer">7339027</span>
+==&gt;CHINA CAT SUNFLOWER=<span class="integer">7322213</span>
+==&gt;CUMBERLAND BLUES=<span class="integer">6730838</span>
+==&gt;RAMBLE ON ROSE=<span class="integer">6676667</span>
+==&gt;LOOKS LIKE RAIN=<span class="integer">6674121</span></code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1260,15 +1352,15 @@ in a graph. Consider the following graph
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.addV(id, "A").as("a").
-  addV(id, "B").as("b").
-  addV(id, "C").as("c").
-  addV(id, "D").as("d").
-  addV(id, "E").as("e").
-  addV(id, "F").
-  addE("link").from("a").to("b").
-  addE("link").from("b").to("c").
-  addE("link").from("d").to("e").iterate()</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.addV(id, <span class="string"><span class="delimiter">&quot;</span><span 
class="content">A</span><span class="delimiter">&quot;</span></span>).as(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">a</span><span class="delimiter">&quot;</span></span>).
+           addV(id, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">B</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">b</span><span 
class="delimiter">&quot;</span></span>).
+           addV(id, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">C</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">c</span><span 
class="delimiter">&quot;</span></span>).
+           addV(id, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">D</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">d</span><span 
class="delimiter">&quot;</span></span>).
+           addV(id, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">E</span><span 
class="delimiter">&quot;</span></span>).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>).
+           addV(id, <span class="string"><span 
class="delimiter">&quot;</span><span class="content">F</span><span 
class="delimiter">&quot;</span></span>).
+           addE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">link</span><span 
class="delimiter">&quot;</span></span>).from(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>).to(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">b</span><span 
class="delimiter">&quot;</span></span>).
+           addE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">link</span><span 
class="delimiter">&quot;</span></span>).from(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">b</span><span 
class="delimiter">&quot;</span></span>).to(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">c</span><span 
class="delimiter">&quot;</span></span>).
+           addE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">link</span><span 
class="delimiter">&quot;</span></span>).from(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">d</span><span 
class="delimiter">&quot;</span></span>).to(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>).iterate()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1276,13 +1368,16 @@ in a graph. Consider the following graph
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V().emit(cyclicPath().or().not(both())).repeat(both()).until(cyclicPath()).
  <b>(1)</b>
-  aggregate("p").by(path()).cap("p").                                          
<b>(2)</b>
-  unfold().limit(local, 1).dedup().                                            
<b>(3)</b>
-  map(__.as("v").select("p").unfold().                                         
<b>(4)</b>
-         filter(unfold().where(eq("v"))).
-         unfold().dedup().order().by(id).fold()
-  ).dedup()                                                                    
<b>(5)</b></pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().emit(cyclicPath().or().not(both())).repeat(both()).until(cyclicPath()). 
<span class="comment">//</span><b>(1)</b>
+           aggregate(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">p</span><span 
class="delimiter">&quot;</span></span>).by(path()).cap(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">p</span><span class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(2)</b>
+           unfold().limit(local, <span class="integer">1</span>).dedup(). 
<span class="comment">//</span><b>(3)</b>
+           map(__.as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>).select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">p</span><span 
class="delimiter">&quot;</span></span>).unfold(). <span 
class="comment">//</span><b>(4)</b>
+                  filter(unfold().where(eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>))).
+                  unfold().dedup().order().by(id).fold()
+           ).dedup() <span class="comment">//</span><b>(5)</b>
+==&gt;[v[A],v[B],v[C]]
+==&gt;[v[D],v[E]]
+==&gt;[v[F]]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1333,12 +1428,15 @@ approach, but one more suited for OLAP e
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.withComputer().V().emit(cyclicPath().or().not(both())).repeat(both()).until(cyclicPath()).
-  aggregate("p").by(path()).cap("p").unfold().limit(local, 1).
-  map(__.as("v").select("p").unfold().
-         filter(unfold().where(eq("v"))).
-         unfold().dedup().order().by(id).fold()
-  ).toSet()</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.withComputer().V().emit(cyclicPath().or().not(both())).repeat(both()).until(cyclicPath()).
+           aggregate(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">p</span><span 
class="delimiter">&quot;</span></span>).by(path()).cap(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">p</span><span 
class="delimiter">&quot;</span></span>).unfold().limit(local, <span 
class="integer">1</span>).
+           map(__.as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>).select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">p</span><span 
class="delimiter">&quot;</span></span>).unfold().
+                  filter(unfold().where(eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">v</span><span 
class="delimiter">&quot;</span></span>))).
+                  unfold().dedup().order().by(id).fold()
+           ).toSet()
+==&gt;[v[A],v[B],v[C]]
+==&gt;[v[D],v[E]]
+==&gt;[v[F]]</code></pre>
 </div>
 </div>
 </div>
@@ -1355,20 +1453,24 @@ depticted below Gremlin could be use to
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.addV(id,'a').as('a').
-  addV(id,'b').as('b').
-  addV(id,'c').as('c').
-  addV(id,'d').as('d').
-  addE('knows').from('a').to('b').
-  addE('knows').from('b').to('c').
-  addE('knows').from('c').to('a').
-  addE('knows').from('a').to('d').
-  addE('knows').from('c').to('d').iterate()
-g.V().as('a').repeat(out().simplePath()).times(2).
-  where(out().as('a')).path()                          <b>(1)</b>
-g.V().as('a').repeat(out().simplePath()).times(2).
-  where(out().as('a')).path().
-  dedup().by(unfold().order().by(id).dedup().fold())   <b>(2)</b></pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">a</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">a</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).
+           addV(id,<span class="string"><span class="delimiter">'</span><span 
class="content">d</span><span class="delimiter">'</span></span>).as(<span 
class="string"><span class="delimiter">'</span><span 
class="content">d</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">knows</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">a</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">knows</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">b</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">knows</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">a</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">knows</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">a</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">d</span><span class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">knows</span><span class="delimiter">'</span></span>).from(<span 
class="string"><span class="delimiter">'</span><span 
class="content">c</span><span class="delimiter">'</span></span>).to(<span 
class="string"><span class="delimiter">'</span><span 
class="content">d</span><span class="delimiter">'</span></span>).iterate()
+gremlin&gt; g.V().as(<span class="string"><span 
class="delimiter">'</span><span class="content">a</span><span 
class="delimiter">'</span></span>).repeat(out().simplePath()).times(<span 
class="integer">2</span>).
+           where(out().as(<span class="string"><span 
class="delimiter">'</span><span class="content">a</span><span 
class="delimiter">'</span></span>)).path() <span 
class="comment">//</span><b>(1)</b>
+==&gt;[v[a],v[b],v[c]]
+==&gt;[v[b],v[c],v[a]]
+==&gt;[v[c],v[a],v[b]]
+gremlin&gt; g.V().as(<span class="string"><span 
class="delimiter">'</span><span class="content">a</span><span 
class="delimiter">'</span></span>).repeat(out().simplePath()).times(<span 
class="integer">2</span>).
+           where(out().as(<span class="string"><span 
class="delimiter">'</span><span class="content">a</span><span 
class="delimiter">'</span></span>)).path().
+           dedup().by(unfold().order().by(id).dedup().fold()) <span 
class="comment">//</span><b>(2)</b>
+==&gt;[v[a],v[b],v[c]]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1393,9 +1495,10 @@ arbitrary length over both incoming and
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V().as('a').repeat(both().simplePath()).emit(loops().is(gt(1))).
-  both().where(eq('a')).path().
-  dedup().by(unfold().order().by(id).dedup().fold())</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().as(<span class="string"><span class="delimiter">'</span><span 
class="content">a</span><span 
class="delimiter">'</span></span>).repeat(both().simplePath()).emit(loops().is(gt(<span
 class="integer">1</span>))).
+           both().where(eq(<span class="string"><span 
class="delimiter">'</span><span class="content">a</span><span 
class="delimiter">'</span></span>)).path().
+           dedup().by(unfold().order().by(id).dedup().fold())
+==&gt;[v[<span class="integer">1</span>],v[<span 
class="integer">3</span>],v[<span class="integer">4</span>],v[<span 
class="integer">1</span>]]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1412,26 +1515,27 @@ that happens to have an eighth bridge (t
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.addV().property(id, 'blue').as('b').
-  addV().property(id, 'orange').as('o').
-  addV().property(id, 'red').as('r').
-  addV().property(id, 'green').as('g').
-  addE('bridge').from('g').to('b').
-  addE('bridge').from('g').to('o').
-  addE('bridge').from('g').to('r').
-  addE('bridge').from('g').to('r').
-  addE('bridge').from('o').to('b').
-  addE('bridge').from('o').to('b').
-  addE('bridge').from('o').to('r').
-  addE('bridge').from('o').to('r').iterate()
-g.V().sideEffect(outE("bridge").aggregate("bridges")).barrier().    <b>(1)</b>
-  repeat(bothE().                                                   <b>(2)</b>
-         or(__.not(select('e')),
-            __.not(filter(__.as('x').select(all, 'e').unfold().     <b>(3)</b>
-                   where(eq('x'))))).as('e').
-         otherV()).
-    until(select(all, 'e').count(local).as("c").                    <b>(4)</b>
-          select("bridges").count(local).where(eq("c"))).hasNext()</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.addV().property(id, <span class="string"><span 
class="delimiter">'</span><span class="content">blue</span><span 
class="delimiter">'</span></span>).as(<span class="string"><span 
class="delimiter">'</span><span class="content">b</span><span 
class="delimiter">'</span></span>).
+           addV().property(id, <span class="string"><span 
class="delimiter">'</span><span class="content">orange</span><span 
class="delimiter">'</span></span>).as(<span class="string"><span 
class="delimiter">'</span><span class="content">o</span><span 
class="delimiter">'</span></span>).
+           addV().property(id, <span class="string"><span 
class="delimiter">'</span><span class="content">red</span><span 
class="delimiter">'</span></span>).as(<span class="string"><span 
class="delimiter">'</span><span class="content">r</span><span 
class="delimiter">'</span></span>).
+           addV().property(id, <span class="string"><span 
class="delimiter">'</span><span class="content">green</span><span 
class="delimiter">'</span></span>).as(<span class="string"><span 
class="delimiter">'</span><span class="content">g</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">g</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">b</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">g</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">o</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">g</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">r</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">g</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">r</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">o</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">b</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">o</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">b</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">o</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">r</span><span 
class="delimiter">'</span></span>).
+           addE(<span class="string"><span class="delimiter">'</span><span 
class="content">bridge</span><span 
class="delimiter">'</span></span>).from(<span class="string"><span 
class="delimiter">'</span><span class="content">o</span><span 
class="delimiter">'</span></span>).to(<span class="string"><span 
class="delimiter">'</span><span class="content">r</span><span 
class="delimiter">'</span></span>).iterate()
+gremlin&gt; g.V().sideEffect(outE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">bridge</span><span 
class="delimiter">&quot;</span></span>).aggregate(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">bridges</span><span 
class="delimiter">&quot;</span></span>)).barrier(). <span 
class="comment">//</span><b>(1)</b>
+           repeat(bothE(). <span class="comment">//</span><b>(2)</b>
+                  or(__.not(select(<span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>)),
+                     __.not(filter(__.as(<span class="string"><span 
class="delimiter">'</span><span class="content">x</span><span 
class="delimiter">'</span></span>).select(all, <span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>).unfold(). <span 
class="comment">//</span><b>(3)</b>
+                            where(eq(<span class="string"><span 
class="delimiter">'</span><span class="content">x</span><span 
class="delimiter">'</span></span>))))).as(<span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>).
+                  otherV()).
+             until(select(all, <span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>).count(local).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">c</span><span 
class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(4)</b>
+                   select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">bridges</span><span 
class="delimiter">&quot;</span></span>).count(local).where(eq(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">c</span><span 
class="delimiter">&quot;</span></span>))).hasNext()
+==&gt;<span class="predefined-constant">true</span></code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1458,14 +1562,15 @@ detected circuit can be displayed with:<
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V().sideEffect(outE("bridge").aggregate("bridges")).barrier().
-  repeat(bothE().or(__.not(select('e')),
-                    __.not(filter(__.as('x').select(all, 'e').unfold().
-                           where(eq('x'))))).as('e').otherV()).
-    until(select(all, 'e').count(local).as("c").
-          select("bridges").count(local).where(eq("c"))).limit(1).
-  path().by(id).by(constant(" -&gt; ")).
-  map {String.join("", it.get().objects())}</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().sideEffect(outE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">bridge</span><span 
class="delimiter">&quot;</span></span>).aggregate(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">bridges</span><span 
class="delimiter">&quot;</span></span>)).barrier().
+           repeat(bothE().or(__.not(select(<span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>)),
+                             __.not(filter(__.as(<span class="string"><span 
class="delimiter">'</span><span class="content">x</span><span 
class="delimiter">'</span></span>).select(all, <span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>).unfold().
+                                    where(eq(<span class="string"><span 
class="delimiter">'</span><span class="content">x</span><span 
class="delimiter">'</span></span>))))).as(<span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>).otherV()).
+             until(select(all, <span class="string"><span 
class="delimiter">'</span><span class="content">e</span><span 
class="delimiter">'</span></span>).count(local).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">c</span><span 
class="delimiter">&quot;</span></span>).
+                   select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">bridges</span><span 
class="delimiter">&quot;</span></span>).count(local).where(eq(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">c</span><span 
class="delimiter">&quot;</span></span>))).limit(<span class="integer">1</span>).
+           path().by(id).by(constant(<span class="string"><span 
class="delimiter">&quot;</span><span class="content"> -&gt; </span><span 
class="delimiter">&quot;</span></span>)).
+           map {<span class="predefined-type">String</span>.join(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="delimiter">&quot;</span></span>, <span 
class="local-variable">it</span>.get().objects())}
+==&gt;orange -&gt; blue -&gt; green -&gt; orange -&gt; red -&gt; green -&gt; 
red -&gt; orange -&gt; blue</code></pre>
 </div>
 </div>
 </div>
@@ -1484,8 +1589,10 @@ that is duplicative of the "created" edg
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V(1).as("a").V(3).addE("created").from("a").iterate()
-g.V(1).outE("created")</pre>
+<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>).V(<span 
class="integer">3</span>).addE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">created</span><span 
class="delimiter">&quot;</span></span>).from(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>).iterate()
+gremlin&gt; g.V(<span class="integer">1</span>).outE(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">created</span><span class="delimiter">&quot;</span></span>)
+==&gt;e[<span class="integer">9</span>][<span 
class="integer">1</span>-created-&gt;<span class="integer">3</span>]
+==&gt;e[<span class="integer">12</span>][<span 
class="integer">1</span>-created-&gt;<span 
class="integer">3</span>]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1493,15 +1600,16 @@ g.V(1).outE("created")</pre>
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V().outE().
-  project("a","b").                         <b>(1)</b>
-    by().by(inV().path().by().by(label)).
-  group().                                  <b>(2)</b>
-    by(select("b")).
-    by(select("a").fold()).
-  unfold().                                 <b>(3)</b>
-  select(values).                           <b>(4)</b>
-  where(count(local).is(gt(1)))</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().outE().
+           project(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">b</span><span 
class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(1)</b>
+             by().by(inV().path().by().by(label)).
+           group(). <span class="comment">//</span><b>(2)</b>
+             by(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">b</span><span 
class="delimiter">&quot;</span></span>)).
+             by(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>).fold()).
+           unfold(). <span class="comment">//</span><b>(3)</b>
+           select(values). <span class="comment">//</span><b>(4)</b>
+           where(count(local).is(gt(<span class="integer">1</span>)))
+==&gt;[e[<span class="integer">9</span>][<span 
class="integer">1</span>-created-&gt;<span class="integer">3</span>],e[<span 
class="integer">12</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>]]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1531,18 +1639,19 @@ that uses less memory might look like th
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V().as("ov").
-  outE().as("e").
-  inV().as("iv").
-  inE().                                          <b>(1)</b>
-  where(neq("e")).                                <b>(2)</b>
-  where(eq("e")).by(label).
-  where(outV().as("ov")).
-  group().
-    by(select("ov","e","iv").by().by(label)).     <b>(3)</b>
-  unfold().                                       <b>(4)</b>
-  select(values).
-  where(count(local).is(gt(1)))</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().as(<span class="string"><span class="delimiter">&quot;</span><span 
class="content">ov</span><span class="delimiter">&quot;</span></span>).
+           outE().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>).
+           inV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">iv</span><span 
class="delimiter">&quot;</span></span>).
+           inE(). <span class="comment">//</span><b>(1)</b>
+           where(neq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>)). <span 
class="comment">//</span><b>(2)</b>
+           where(eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>)).by(label).
+           where(outV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ov</span><span 
class="delimiter">&quot;</span></span>)).
+           group().
+             by(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ov</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">iv</span><span 
class="delimiter">&quot;</span></span>).by().by(label)). <span 
class="comment">//</span><b>(3)</b>
+           unfold(). <span class="comment">//</span><b>(4)</b>
+           select(values).
+           where(count(local).is(gt(<span class="integer">1</span>)))
+==&gt;[e[<span class="integer">12</span>][<span 
class="integer">1</span>-created-&gt;<span class="integer">3</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>]]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1572,18 +1681,19 @@ value.</p>
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.V().match(
-    __.as("ov").outE().as("e"),
-    __.as("e").inV().as("iv"),
-    __.as("iv").inE().as("ie"),
-    __.as("ie").outV().as("ov")).
-      where("ie",neq("e")).
-      where("ie",eq("e")).by(label).
-    select("ie").
-    group().
-      by(select("ov","e","iv").by().by(label)).
-    unfold().select(values).
-      where(count(local).is(gt(1)))</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().match(
+             __.as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ov</span><span 
class="delimiter">&quot;</span></span>).outE().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>),
+             __.as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>).inV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">iv</span><span 
class="delimiter">&quot;</span></span>),
+             __.as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">iv</span><span 
class="delimiter">&quot;</span></span>).inE().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ie</span><span 
class="delimiter">&quot;</span></span>),
+             __.as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ie</span><span 
class="delimiter">&quot;</span></span>).outV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ov</span><span 
class="delimiter">&quot;</span></span>)).
+               where(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ie</span><span 
class="delimiter">&quot;</span></span>,neq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>)).
+               where(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ie</span><span 
class="delimiter">&quot;</span></span>,eq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>)).by(label).
+             select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ie</span><span 
class="delimiter">&quot;</span></span>).
+             group().
+               by(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ov</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">iv</span><span 
class="delimiter">&quot;</span></span>).by().by(label)).
+             unfold().select(values).
+               where(count(local).is(gt(<span class="integer">1</span>)))
+==&gt;[e[<span class="integer">12</span>][<span 
class="integer">1</span>-created-&gt;<span class="integer">3</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>]]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1593,13 +1703,15 @@ as a performance optimization.</p>
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.withoutStrategies(LazyBarrierStrategy, 
PathRetractionStrategy).V().as("ov").   <b>(1)</b>
-  outE().as("e1").
-  inV().as("iv").
-  inE().
-  where(neq("e1")).
-  where(outV().as("ov")).as("e2").                                             
  <b>(2)</b>
-  filter(select("e1","e2").by(label).where("e1", eq("e2")))                    
  <b>(3)</b></pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.withoutStrategies(LazyBarrierStrategy, PathRetractionStrategy).V().as(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">ov</span><span class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(1)</b>
+           outE().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e1</span><span 
class="delimiter">&quot;</span></span>).
+           inV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">iv</span><span 
class="delimiter">&quot;</span></span>).
+           inE().
+           where(neq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e1</span><span 
class="delimiter">&quot;</span></span>)).
+           where(outV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ov</span><span 
class="delimiter">&quot;</span></span>)).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e2</span><span 
class="delimiter">&quot;</span></span>). <span 
class="comment">//</span><b>(2)</b>
+           filter(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e1</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e2</span><span 
class="delimiter">&quot;</span></span>).by(label).where(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">e1</span><span class="delimiter">&quot;</span></span>, eq(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">e2</span><span class="delimiter">&quot;</span></span>))) <span 
class="comment">//</span><b>(3)</b>
+==&gt;e[<span class="integer">12</span>][<span 
class="integer">1</span>-created-&gt;<span class="integer">3</span>]
+==&gt;e[<span class="integer">9</span>][<span 
class="integer">1</span>-created-&gt;<span 
class="integer">3</span>]</code></pre>
 </div>
 </div>
 <div class="colist arabic">
@@ -1625,7 +1737,7 @@ the approach might look something like t
 </div>
 <div class="listingblock">
 <div class="content">
-<pre></pre>
+<pre class="CodeRay"><code class="groovy language-groovy"></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1634,10 +1746,14 @@ demonstration, an additional edge is add
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g = TinkerFactory.createModern().traversal()
-g.V(1).as("a").V(3).addE("created").property("weight",0.4d).from("a").iterate()
-g.V(1).as("a").V(3).addE("created").property("weight",0.5d).from("a").iterate()
-g.V(1).outE("created").valueMap(true)</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g = 
TinkerFactory.createModern().traversal()
+==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">6</span> <span class="key">edges</span>:<span 
class="integer">6</span>], standard]
+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>).V(<span 
class="integer">3</span>).addE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">created</span><span 
class="delimiter">&quot;</span></span>).property(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">weight</span><span 
class="delimiter">&quot;</span></span>,<span 
class="float">0.4d</span>).from(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>).iterate()
+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>).V(<span 
class="integer">3</span>).addE(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">created</span><span 
class="delimiter">&quot;</span></span>).property(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">weight</span><span 
class="delimiter">&quot;</span></span>,<span 
class="float">0.5d</span>).from(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">a</span><span 
class="delimiter">&quot;</span></span>).iterate()
+gremlin&gt; g.V(<span class="integer">1</span>).outE(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">created</span><span 
class="delimiter">&quot;</span></span>).valueMap(<span 
class="predefined-constant">true</span>)
+==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span 
class="key">weight</span>:<span class="float">0.4</span>,<span 
class="key">label</span>:created]
+==&gt;[<span class="key">id</span>:<span class="integer">12</span>,<span 
class="key">weight</span>:<span class="float">0.4</span>,<span 
class="key">label</span>:created]
+==&gt;[<span class="key">id</span>:<span class="integer">13</span>,<span 
class="key">weight</span>:<span class="float">0.5</span>,<span 
class="key">label</span>:created]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1645,14 +1761,16 @@ g.V(1).outE("created").valueMap(true)</p
 </div>
 <div class="listingblock">
 <div class="content">
-<pre>g.withoutStrategies(LazyBarrierStrategy, 
PathRetractionStrategy).V().as("ov").
-  outE().as("e1").
-  inV().as("iv").
-  inE().
-  where(neq("e1")).
-  where(outV().as("ov")).as("e2").
-  filter(select("e1","e2").by(label).where("e1", eq("e2"))).
-  filter(select("e1","e2").by("weight").where("e1", 
eq("e2"))).valueMap(true)</pre>
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.withoutStrategies(LazyBarrierStrategy, PathRetractionStrategy).V().as(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">ov</span><span class="delimiter">&quot;</span></span>).
+           outE().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e1</span><span 
class="delimiter">&quot;</span></span>).
+           inV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">iv</span><span 
class="delimiter">&quot;</span></span>).
+           inE().
+           where(neq(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e1</span><span 
class="delimiter">&quot;</span></span>)).
+           where(outV().as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">ov</span><span 
class="delimiter">&quot;</span></span>)).as(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e2</span><span 
class="delimiter">&quot;</span></span>).
+           filter(select(<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e1</span><span 
class="delimiter">&quot;</span></span>,<span class="string"><span 
class="delimiter">&quot;</span><span class="content">e2</span><span 
class="delimiter">&quot;</span></span>).by(label).where(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">e1</span><span class="delimiter">&quot;</span></span>, eq(<span 
class="string"><span class="delimiter">&quot;</span><span 
class="content">e2</span><span class="delimiter">&quot;</span></span>))).

[... 1669 lines stripped ...]

Reply via email to