anchor.diff:  g.V().out().out().as('x').back('x') // pointless
   ----
   
  +[[by-step]]
  +By Step
  +~~~~~~~
  +
  +The `by()`-step is not an actual step, but instead is a "step-modulator" similar to <<as-step,`as()`>> and <<option-step,`option()`>>. If a step is able to accept traversals, functions, comparators, etc. then `by()` is the means by which they are added. The general pattern is `step().by()...by()`. Some steps can only accept one `by()` while others, and arbitrary amount.
  +
  +[gremlin-groovy,modern]
  +----
  +g.V().group().by(bothE().count())                              <1>
  +g.V().group().by(bothE().count()).by('name')                   <2>
  +g.V().group().by(bothE().count()).by('name').by{it.size()}     <3>
  +----
  +
  +<1> `by(outE().count())` will group the elements by their edge count (*traversal*).
  +<2> `by('name')` will process the grouped elements by their name (*element property projection*).
  +<3> `by{it.size()}` will count the number of elements in each group (*function*).
  +
   [[count-step]]
   Count Step
   ~~~~~~~~~~
  
positive.code:         option('josh', values('name')).
          option('vadas', valueMap()).
          option('peter', label())
  ----
  
  [[coin-step]]
  
negative.code: link:http://en.wikipedia.org/wiki/Functional_programming[Functional languages] make use of function composition and lazy evaluation to create complex computations from primitive operations. This is exactly what Gremlin `GraphTraversal` does. One of the differentiating aspects of Gremlin's data flow approach to graph processing is that the flow need not always go "forward," but in fact, can go back to a previously seen area of computation. Examples include <<repeat-step,`repeat()`>> as well as the `back()`-step (*map*).
  
  [gremlin-groovy,modern]
  ----
  g.V().out().out()
  g.V().out().out().path()
  g.V().as('x').out().out().back('x')
  