anchor.diff:          option('josh', values('name')).
           option('vadas', valueMap()).
           option('peter', label())
  +----
  +
  +The `choose()`-step can leverage the `Pick.none` option match. For anything that does not match a specified option, the `none`-option is taken.
  +
  +[gremlin-groovy,modern]
  +----
  +g.V().has(label,'person').
  +      choose(values('name')).
  +        option('marko', values('age')).
  +        option(none, values('name'))
   ----
   
   [[coin-step]]
  
positive.code: Choose Step
  ~~~~~~~~~~~
  
  The `choose()`-step (*branch*) allows for the current traverser to select which traversal branch to take. With `choose()`, it is possible to implement if/else-based semantics. The first set of examples below provide information about the vertices of the graph so its easier to understand the `choose()` examples to follow.
  
  [gremlin-groovy,modern]
  ----
  g.V().has(label,'person').values('name').map {[it.get(), it.get().length()]}
  g.V().has(label,'person').filter {
      it.get().value('name').length() == 5
  }.in().values('name')
  g.V().has(label,'person').filter {
      it.get().value('name').length() == 4
  }.out().values('name')
  ----
  
  Given the facts above, the following examples show how to use `choose()` to select the values.
  
  image::choose-step.png[width=700]
  
  [gremlin-groovy,modern]
  ----
  g.V().has(label,'person').
        choose({ it.value('name').length() == 5},
                 __.in(), out()).values('name') <1>
  g.V().has(label,'person').
        choose {it.value('name').length()}.
          option(5, __.in()).
          option(4, out()).values('name') <2>
  ----
  
  <1> If the predicate is true, then do `in`, else do `out`.
  <2> Use the result of the function as a key to the map of traversal choices.
  
  However, note that `choose()` can have an arbitrary number of options and moreover, can take a anonymous traversal as its choice function.
  
  [gremlin-groovy,modern]
  ----
  
negative.code: g.V().out('knows').aggregate().by('name')
  ----
  
  [[as-step]]
  As Step
  ~~~~~~~
  
  The `as()`-step is not a real step, but a "step modulator" similar to <<by-step,`by()`>> and <<option-step,`option()`>>. With `as()`, it is possible to provide a label to the step that can later be accessed by steps and data structures that make use of such labels -- e.g., <<select-step,`select()`>>, <<match-step,`match()`>>, and path.
  
  [gremlin-groovy,modern]
  ----
  g.V().as('a').out('created').as('b').select()            <1>
  g.V().as('a').out('created').as('b').select().by('name') <2>
  ----
  
  <1> Select the objects labeled "a" and "b" from the path.
  <2> Select the objects labeled "a" and "b" from the path and, for each object, project its name value.
  
  [[back-step]]
  Back Step
  ~~~~~~~~~
  