g.V(1).out().values('name') (1)
g.V(1).out().map {it.get().value('name')} (2)
g.V(1).out().map(values('name')) (3)

g.V().filter {it.get().label() == 'person'} (1)
g.V().filter(label().is('person')) (2)
g.V().hasLabel('person') (3)

g.V().hasLabel('person').sideEffect(System.out.&println) (1)
g.V().sideEffect(outE().count().store("o")).
      sideEffect(inE().count().store("i")).cap("o","i") (2)

g.V().branch {it.get().value('name')}.
      option('marko', values('age')).
      option(none, values('name')) (1)
g.V().branch(values('name')).
      option('marko', values('age')).
      option(none, values('name')) (2)
g.V().choose(has('name','marko'),
             values('age'),
             values('name')) (3)

g.V().out('created').hasNext() (1)
g.V().out('created').next() (2)
g.V().out('created').next(2) (3)
g.V().out('nothing').tryNext() (4)
g.V().out('created').toList() (5)
g.V().out('created').toSet() (6)
g.V().out('created').toBulkSet() (7)
results = ['blah',3]
g.V().out('created').fill(results) (8)
g.addV('person').iterate() (9)

g.addV('product').property('name', 'GDB').property(id, "1") (1)
g.addV('entity').property('name', 'aliyun')
g.V().has('entity','name','aliyun').id() (2)
g.addV('product').property('name', 'gremlin').property('id', "25") (3)

g.V(1).as('a').out('created').in('created').where(neq('a')).
  addE('co-developer').from('a').property('year',2009) (1)
g.V(3,4,5).aggregate('x').has('name','josh').as('a').
  select('x').unfold().hasLabel('software').addE('createdBy').to('a') (2)
g.V().as('a').out('created').addE('createdBy').to('a').property('acl','public') (3)
g.V(1).as('a').out('knows').
  addE('livesNear').from('a').property('year',2009).
  inV().inE('livesNear').values('year') (4)
g.V().match(
        __.as('a').out('knows').as('b'),
        __.as('a').out('created').as('c'),
        __.as('b').out('created').as('c')).
      addE('friendlyCollaborator').from('a').to('b').
        property(id,23).property('project',select('c').values('name')) (5)
g.E(23).valueMap()
marko = g.V().has('name','marko').next()
peter = g.V().has('name','peter').next()
g.V(marko).addE('knows').to(peter) (6)
g.addE('knows').from(marko).to(peter) (7)

g.addV('person').property('name','stephen')
g.V().values('name')
g.V().outE('knows').addV().property('name','nothing')
g.V().has('name','nothing')
g.V().has('name','nothing').bothE()

g.V(1).property('country','usa')
g.V(1).property('city','santa fe').property('state','new mexico').valueMap()
g.V(1).property(list,'age',35)  (1)
g.V(1).valueMap()
g.V(1).property('friendWeight',outE('knows').values('weight').sum(),'acl','private') (2)
g.V(1).properties('friendWeight').valueMap() (3)

g.V(1).out('created') (1)
g.V(1).out('created').aggregate('x') (2)
g.V(1).out('created').aggregate('x').in('created') (3)
g.V(1).out('created').aggregate('x').in('created').out('created') (4)
g.V(1).out('created').aggregate('x').in('created').out('created').
       where(without('x')).values('name') (5)

g.V().out('knows').aggregate('x').cap('x')
g.V().out('knows').aggregate('x').by('name').cap('x')

g.V().and(
   outE('knows'),
   values('age').is(lt(30))).
     values('name')

g.V().where(outE('created').and().outE('knows')).values('name')

g.V().as('a').out('created').as('b').select('a','b')            (1)
g.V().as('a').out('created').as('b').select('a','b').by('name') (2)

g.V().hasLabel('software').as('a','b','c').
   select('a','b','c').
     by('name').
     by('lang').
     by(__.in('created').values('name').fold())

g.V().sideEffect{println "first: ${it}"}.sideEffect{println "second: ${it}"}.iterate()
g.V().sideEffect{println "first: ${it}"}.barrier().sideEffect{println "second: ${it}"}.iterate()

graph = TinkerGraph.open()
g = graph.traversal()
g.io('data/grateful-dead.xml').read().iterate()
g = graph.traversal().withoutStrategies(LazyBarrierStrategy) (1)
clockWithResult(1){g.V().both().both().both().count().next()} (2)
clockWithResult(1){g.V().repeat(both()).times(3).count().next()} (3)
clockWithResult(1){g.V().both().barrier().both().barrier().both().barrier().count().next()} (4)

graph = TinkerGraph.open()
g = graph.traversal()  (1)
g.io('data/grateful-dead.xml').read().iterate()
clockWithResult(1){g.V().both().both().both().count().next()}
g.V().both().both().both().count().iterate().toString()  (2)

g.V().group().by(bothE().count()) (1)
g.V().group().by(bothE().count()).by('name') (2)
g.V().group().by(bothE().count()).by(count())  (3)

g.V().groupCount('a').by(label).cap('a')      (1)
g.V().groupCount('a').by(label).groupCount('b').by(outE().count()).cap('a','b')   (2)

g.V().hasLabel('person').
      choose(values('age').is(lte(30)),
        __.in(),
        __.out()).values('name') (1)
g.V().hasLabel('person').
      choose(values('age')).
        option(27, __.in()).
        option(32, __.out()).values('name') (2)

g.V().choose(hasLabel('person'), out('created')).values('name') (1)
g.V().choose(hasLabel('person'), out('created'), identity()).values('name') (2)

g.V().hasLabel('person').
      choose(values('name')).
        option('marko', values('age')).
        option('josh', values('name')).
        option('vadas', valueMap()).
        option('peter', label())

g.V().hasLabel('person').
      choose(values('name')).
        option('marko', values('age')).
        option(none, values('name'))

g.V(1).coalesce(outE('knows'), outE('created')).inV().path().by('name').by(label)
g.V(1).coalesce(outE('created'), outE('knows')).inV().path().by('name').by(label)
g.V(1).property('nickname', 'okram')
g.V().hasLabel('person').coalesce(values('nickname'), values('name'))

g.V().coin(0.5)
g.V().coin(0.0)
g.V().coin(1.0)

g = graph.traversal().withComputer()
g.V().
  connectedComponent().
    with(ConnectedComponent.propertyName, 'component').
  project('name','component').
    by('name').
    by('component')
g.V().hasLabel('person').
  connectedComponent().
    with(ConnectedComponent.propertyName, 'component').
    with(ConnectedComponent.edges, outE('knows')).
  project('name','component').
    by('name').
    by('component')

g.V().choose(hasLabel('person'),
    values('name'),
    constant('inhuman')) (1)
g.V().coalesce(
    hasLabel('person').values('name'),
    constant('inhuman')) (2)

g.V().count()
g.V().hasLabel('person').count()
g.V().hasLabel('person').outE('created').count().path()  (1)
g.V().hasLabel('person').outE('created').count().map {it.get() * 10}.path() (2)

g.V(1).both().both()
g.V(1).both().both().cyclicPath()
g.V(1).both().both().cyclicPath().path()
g.V(1).as('a').out('created').as('b').
  in('created').as('c').
  cyclicPath().
  path()
g.V(1).as('a').out('created').as('b').
  in('created').as('c').
  cyclicPath().from('a').to('b').
  path()

g.V().values('lang')
g.V().values('lang').dedup()
g.V(1).repeat(bothE('created').dedup().otherV()).emit().path() (1)

g.V().valueMap('name').with(WithOptions.tokens)
g.V().dedup().by(label).values('name')

g.V().as('a').out('created').as('b').in('created').as('c').select('a','b','c')
g.V().as('a').out('created').as('b').in('created').as('c').dedup('a','b').select('a','b','c') (1)

g.V().outE().drop()
g.E()
g.V().properties('name').drop()
g.V().valueMap()
g.V().drop()
g.V()

g.V().hasLabel('person').outE().identity().inV().count().is(gt(5)).explain()

g.V(1).out('knows').values('name')
g.V(1).out('knows').values('name').fold() (1)
g.V(1).out('knows').values('name').fold().next().getClass() (2)
g.V(1).out('knows').values('name').fold(0) {a,b -> a + b.length()} (3)
g.V().values('age').fold(0) {a,b -> a + b} (4)
g.V().values('age').fold(0, sum) (5)
g.V().values('age').sum() (6)

g.V().has('name', within('marko', 'vadas', 'josh')).as('person').
  V().has('name', within('lop', 'ripple')).addE('uses').from('person')

g.V().has('name', within('marko', 'vadas', 'josh')).as('person').
  V().has('name', within('lop', 'ripple')).addE('uses').from('person').toString() (1)
g.V().has('name', within('marko', 'vadas', 'josh')).as('person').
  V().has('name', within('lop', 'ripple')).addE('uses').from('person').iterate().toString() (2)

g.V().group().by(label) (1)
g.V().group().by(label).by('name') (2)
g.V().group().by(label).by(count()) (3)

g.V().hasLabel('person').values('age').groupCount()
g.V().hasLabel('person').groupCount().by('age') (1)

g.V().repeat(both().groupCount('m').by(label)).times(10).cap('m')

g.V().hasLabel('person')
g.V().hasLabel('person').out().has('name',within('vadas','josh'))
g.V().hasLabel('person').out().has('name',within('vadas','josh')).
      outE().hasLabel('created')
g.V().has('age',inside(20,30)).values('age') (1)
g.V().has('age',outside(20,30)).values('age') (2)
g.V().has('name',within('josh','marko')).valueMap() (3)
g.V().has('name',without('josh','marko')).valueMap() (4)
g.V().has('name',not(within('josh','marko'))).valueMap() (5)
g.V().properties().hasKey('age').value() (6)
g.V().hasNot('age').values('name') (7)

g.V().id()
g.V(1).out().id().is(2)
g.V(1).outE().id()
g.V(1).properties().id()

g.V().identity()

g.V().hasLabel("software").index()  (1)
g.V().hasLabel("software").values("name").fold().
  order(Scope.local).
  index().
  unfold().
  order().
    by(__.tail(Scope.local, 1))     (2)
g.V().hasLabel("software").values("name").fold().
  order(Scope.local).
  index().
    with(WithOptions.indexer, WithOptions.list).
  unfold().
  order().
    by(__.tail(Scope.local, 1))     (3)
g.V().hasLabel("person").values("name").fold().
  order(Scope.local).
  index().
    with(WithOptions.indexer, WithOptions.map)  (4)

g.V(4).out().values('name').inject('daniel')
g.V(4).out().values('name').inject('daniel').map {it.get().length()}
g.V(4).out().values('name').inject('daniel').map {it.get().length()}.path()

inject(1,2)
inject(1,2).map {it.get() + 1}
inject(1,2).map {it.get() + 1}.map {g.V(it.get()).next()}.values('name')

g.io(someInputFile).read().iterate()
g.io(someOutputFile).write().iterate()

g.io(someInputFile).
    with(IO.reader, IO.graphson).
  read().iterate()
g.io(someOutputFile).
    with(IO.writer,IO.graphml).
  write().iterate()

g.io(someInputFile).
    with(IO.reader, IO.gryo).
    with(IO.registry, TinkerIoRegistryV3d0.instance())
  read().iterate()
g.io(someOutputFile).
    with(IO.writer,IO.graphson).
    with(IO.registry, "org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3d0")
  write().iterate()

g.V().values('age').is(32)
g.V().values('age').is(lte(30))
g.V().values('age').is(inside(30, 40))
g.V().where(__.in('created').count().is(1)).values('name') (1)
g.V().where(__.in('created').count().is(gte(2))).values('name') (2)
g.V().where(__.in('created').values('age').
                           mean().is(inside(30d, 35d))).values('name') (3)

g.V(1).properties().key()
g.V(1).properties().properties().key()

g.V().label()
g.V(1).outE().label()
g.V(1).properties().label()

g.V().limit(2)
g.V().range(0, 2)

g.V().valueMap().select('location').limit(local,2) (1)
g.V().valueMap().limit(local, 1) (2)

g.V().as('person').
      properties('location').order().by('startTime',asc).limit(2).value().as('location').
      select('person','location').by('name').by() (1)
g.V().as('person').
      local(properties('location').order().by('startTime',asc).limit(2)).value().as('location').
      select('person','location').by('name').by() (2)

g.V().both().barrier().flatMap(groupCount().by("name"))
g.V().both().barrier().local(groupCount().by("name"))

g.V().emit(__.has("name", "marko").or().loops().is(2)).repeat(__.out()).values("name")

g.V().match(
        __.as('a').out('created').as('b'),
        __.as('b').has('name', 'lop'),
        __.as('b').in('created').as('c'),
        __.as('c').has('age', 29)).
      select('a','c').by('name')

g.V().match(
        __.as('a').out('created').has('name', 'lop').as('b'),
        __.as('b').in('created').has('age', 29).as('c')).
      select('a','c').by('name')

g.V().match(
        __.as('creators').out('created').has('name', 'lop').as('projects'), (1)
        __.as('projects').in('created').has('age', 29).as('cocreators')). (2)
      select('creators','cocreators').by('name') (3)

g = graph.traversal()
g.io('data/grateful-dead.xml').read().iterate()
g.V().match(
        __.as('a').has('name', 'Garcia'),
        __.as('a').in('writtenBy').as('b'),
        __.as('a').in('sungBy').as('b')).
      select('b').values('name')

g.V().match(
        __.as('a').out('created').has('name','lop').as('b'), (1)
        __.as('b').in('created').has('age', 29).as('c'),
        __.as('c').repeat(out()).times(2)). (2)
      select('c').out('knows').dedup().values('name') (3)

g.V().match(
        __.as('a').out('knows').as('b'),
        __.as('b').out('created').has('name','lop')).
      select('b').out('created').
        match(
          __.as('x').in('created').as('y'),
          __.as('y').out('knows').as('z')).
      select('z').values('name')

g.V().match(
        __.as('a').out('knows').as('b'),
        __.as('b').out('created').has('name','lop'),
        __.as('b').match(
                     __.as('b').out('created').as('c'),
                     __.as('c').has('name','ripple')).
                   select('c').as('c')).
      select('a','c').by('name')

g.V().as('a').out('knows').as('b').
  match(
    __.as('b').out('created').as('c'),
    __.not(__.as('c').in('created').as('a'))).
  select('a','b','c').by('name')

g.V().as('a').out().as('b'). (1)
    match( (2)
      __.as('a').out().count().as('c'), (3)
      __.not(__.as('a').in().as('b')), (4)
      or( (5)
        __.as('a').out('knows').as('b'),
        __.as('b').in().count().as('c').and().as('c').is(gt(2)))).  (6)
    dedup('a','c'). (7)
    select('a','b','c').by('name').by('name').by() (8)

g.V().as('a').out('knows').as('b').math('a + b').by('age')
g.V().as('a').out('created').as('b').
  math('b + a').
    by(both().count().math('_ + 100')).
    by('age')
g.withSideEffect('x',10).V().values('age').math('_ / x')
g.withSack(1).V(1).repeat(sack(sum).by(constant(1))).times(10).emit().sack().math('sin _')

g.V().values('age').max()
g.V().repeat(both()).times(3).values('age').max()
g.V().values('name').max()

g.V().values('age').mean()
g.V().repeat(both()).times(3).values('age').mean() (1)
g.V().repeat(both()).times(3).values('age').dedup().mean()

g.V().values('age').min()
g.V().repeat(both()).times(3).values('age').min()
g.V().values('name').min()

g.V().not(hasLabel('person')).valueMap().with(WithOptions.tokens)
g.V().hasLabel('person').
  not(out('created').count().is(gt(1))).values('name')   (1)

g.V(2).optional(out('knows')) (1)
g.V(2).optional(__.in('knows')) (2)

g.V().hasLabel('person').optional(out('knows').optional(out('created'))).path() (1)

g.V().or(
   __.outE('created'),
   __.inE('created').count().is(gt(1))).
     values('name')

g.V().where(outE('created').or().outE('knows')).values('name')

g.V().values('name').order()
g.V().values('name').order().by(desc)
g.V().hasLabel('person').order().by('age', asc).values('name')

g.V().values('name')
g.V().order().by('name',asc).values('name')
g.V().order().by('name',desc).values('name')

g.V().hasLabel('person').order().by(outE('created').count(), asc).
                                 by('age', asc).values('name')
g.V().hasLabel('person').order().by(outE('created').count(), asc).
                                 by('age', desc).values('name')

g.V().hasLabel('person').order().by(shuffle)
g.V().hasLabel('person').order().by(shuffle)

g.V().values('age').fold().order(local).by(desc) (1)
g.V().values('age').order(local).by(desc) (2)
g.V().groupCount().by(inE().count()).order(local).by(values, desc) (3)
g.V().groupCount().by(inE().count()).order(local).by(keys, asc) (4)

g = graph.traversal().withComputer()
g.V().pageRank().by('pageRank').values('pageRank')
g.V().hasLabel('person').
  pageRank().
    with(PageRank.edges, __.outE('knows')).
    with(PageRank.propertyName, 'friendRank').
  order().by('friendRank',desc).valueMap('name','friendRank')

g = graph.traversal().withComputer()
g.V().hasLabel('person').
  pageRank().
    with(PageRank.edges, __.outE('knows')).
    with(PageRank.propertyName, 'friendRank').
  order().by('friendRank',desc).valueMap('name','friendRank').explain()

g.V().out().out().values('name')
g.V().out().out().values('name').path()

g.V().outE().inV().outE().inV().path()

g.V().out().out().path().by('name').by('age')

g.V().out().out().path().by(
                   choose(hasLabel('person'),
                                 out('created').values('name'),
                                 __.in('created').values('name')).fold())

g = graph.traversal().withComputer()
g.V().peerPressure().by('cluster').values('cluster')
g.V().hasLabel('person').
  peerPressure().
    with(PeerPressure.propertyName, 'cluster').
  group().
    by('cluster').
    by('name')

g.V().out('created').repeat(both()).times(3).hasLabel('person').values('age').sum().profile()

t = g.V().out('created').profile('metrics')
t.iterate()
metrics = t.getSideEffects().get('metrics')

g.V().out('created').
  project('a','b').
    by('name').
    by(__.in('created').count()).
  order().by(select('b'),desc).
  select('a')
g.V().has('name','marko').
               project('out','in').
                 by(outE().count()).
                 by(inE().count())

private TraverserSet<Object> haltedTraversers;

public void loadState(Graph graph, Configuration configuration) {
  VertexProgram.super.loadState(graph, configuration);
  this.traversal = PureTraversal.loadState(configuration, VertexProgramStep.ROOT_TRAVERSAL, graph);
  this.programStep = new TraversalMatrix<>(this.traversal.get()).getStepById(configuration.getString(ProgramVertexProgramStep.STEP_ID));
  // 如果遍历的“副作用”在计算中将被使用，那么将其添加为一个内存计算key
  this.memoryComputeKeys.addAll(MemoryTraversalSideEffects.getMemoryComputeKeys(this.traversal.get()));
  // 如果主遍历要被复制，那么也创建一个内存计算的key
  this.memoryComputeKeys.add(MemoryComputeKey.of(TraversalVertexProgram.HALTED_TRAVERSERS, Operator.addAll, false, false));
  // 如果没有停止的遍历器，那么就返回一个空遍历器
  this.haltedTraversers = TraversalVertexProgram.loadHaltedTraversers(configuration);
}

public void storeState(Configuration configuration) {
  VertexProgram.super.storeState(configuration);
  // 如果停止的遍历器为空，那么什么也不做
  TraversalVertexProgram.storeHaltedTraversers(configuration, this.haltedTraversers);
}

public void setup(Memory memory) {
  if(!this.haltedTraversers.isEmpty()) {
    // 这里做你想对哪些停止的主遍历做的事情
  }
  // 一旦做了操作，也就不用在主遍历器里保留这些信息了
  this.haltedTraversers = null;
}

public void execute(Vertex vertex, Messenger messenger, Memory memory) {
  // 一旦做了操作，也就不用在工作线程里保留这些信息了
  once used, no need to keep that information around (workers)
  if(null != this.haltedTraversers)
    this.haltedTraversers = null;
  if(vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()) {
    // 在 execute() 中的haltedTraversers 代表那些正在进行遍历的遍历器（worker-traversal）
    // 比如，从g.V().out().program(...) 而来的遍历
    TraverserSet<Object> haltedTraversers = vertex.value(TraversalVertexProgram.HALTED_TRAVERSERS);
    // 创建一个被停止的遍历器集合，一边在后续OLAP 任务链中使用
    // 这些正在工作的遍历器可能分布在整个图中
    TraverserSet<Object> newHaltedTraversers = new TraverserSet<>();
    haltedTraversers.forEach(traverser -> {
       newHaltedTraversers.add(traverser.split(traverser.get().toString(), this.programStep));
    });
    vertex.property(VertexProperty.Cardinality.single, TraversalVertexProgram.HALTED_TRAVERSERS, newHaltedTraversers);
    // 可以在主遍历中，创建一些主遍历器（这也是将最终结果返回给用户的方法）
    memory.add(TraversalVertexProgram.HALTED_TRAVERSERS,
               new TraverserSet<>(this.traversal().get().getTraverserGenerator().generate("an example", this.programStep, 1l)));
  }

public boolean terminate(Memory memory) {
  // 主遍历器将包含很多停止的遍历器
  assert memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS);
  TraverserSet<String> haltedTraversers = memory.get(TraversalVertexProgram.HALTED_TRAVERSERS);
  // 这里只有通过memory内存将这些遍历器发送给主遍历
  assert haltedTraversers.stream().map(Traverser::get).filter(s -> s.equals("an example")).findAny().isPresent();
  // 这里将不包含分布在各个顶点上的工作遍历器
  assert !haltedTraversers.stream().map(Traverser::get).filter(s -> !s.equals("an example")).findAny().isPresent();
  return true;
}

g = graph.traversal().withComputer()
g.V().hasLabel('person').
  program(PageRankVertexProgram.build().property('rank').create(graph)).
    order().by('rank', asc).
  valueMap('name', 'rank')

g.V(1).properties()
g.V(1).properties('location').valueMap()
g.V(1).properties('location').has('endTime').valueMap()

g.V().propertyMap()
g.V().propertyMap('age')
g.V().propertyMap('age','blah')
g.E().propertyMap()

g.V().range(0,3)
g.V().range(1,3)
g.V().range(1, -1)
g.V().repeat(both()).times(1000000).emit().range(6,10)

g.V().as('a').out().as('b').in().as('c').select('a','b','c').by('name').range(local,1,2)

g.V().valueMap().select('location').range(local, 1, 3)

g.V(1).repeat(out()).times(2).path().by('name') (1)
g.V().until(has('name','ripple')).
      repeat(out()).path().by('name') (2)

g.V(1).repeat(out()).times(2).emit().path().by('name') (1)
g.V(1).emit().repeat(out()).times(2).path().by('name') (2)

g.V(1).repeat(out()).times(2).emit(has('lang')).path().by('name')

g.V(1).repeat(out()).times(2).emit().path().by('name')

g.V(1).
  repeat(out("knows")).
    until(repeat(out("created")).emit(has("name", "lop"))) (1)
g.V(6).
  repeat('a', both('created').simplePath()).
    emit(repeat('b', both('knows')).
           until(loops('b').as('b').where(loops('a').as('b'))).
  hasId(2)).dedup() (2)

g.V(1).repeat(out()).until(hasLabel('software')).path().by('name') (1)
g.V(1).emit(hasLabel('person')).repeat(out()).path().by('name') (2)
g.V(1).repeat(out()).until(outE().count().is(0)).path().by('name') (3)

g.withSack(1.0f).V().sack()
rand = new Random()
g.withSack {rand.nextFloat()}.V().sack()

g.withSack(1.0f).V().repeat(outE().sack(mult).by('weight').inV()).times(2)
g.withSack(1.0f).V().repeat(outE().sack(mult).by('weight').inV()).times(2).sack()
g.withSack(1.0f).V().repeat(outE().sack(mult).by('weight').inV()).times(2).path().
      by().by('weight')

g.withSack {[:]}.V().out().out().
      sack {m,v -> m[v.value('name')] = v.value('lang'); m}.sack() // BAD: single map
g.withSack {[:]}{it.clone()}.V().out().out().
      sack {m,v -> m[v.value('name')] = v.value('lang'); m}.sack() // GOOD: cloned map

g.withSack(1.0d).V(1).out('knows').in('knows') (1)
g.withSack(1.0d).V(1).out('knows').in('knows').sack() (2)
g.withSack(1.0d, sum).V(1).out('knows').in('knows').sack() (3)
g.withSack(1.0d).V(1).local(outE('knows').barrier(normSack).inV()).in('knows').barrier() (4)
g.withSack(1.0d).V(1).local(outE('knows').barrier(normSack).inV()).in('knows').barrier().sack() (5)
g.withSack(1.0d,sum).V(1).local(outE('knows').barrier(normSack).inV()).in('knows').barrier().sack() (6)
g.withBulk(false).withSack(1.0f,sum).V(1).local(outE('knows').barrier(normSack).inV()).in('knows').barrier().sack() (7)
g.withBulk(false).withSack(1.0f).V(1).local(outE('knows').barrier(normSack).inV()).in('knows').barrier().sack()(8)

g.V().outE().sample(1).values('weight')
g.V().outE().sample(1).by('weight').values('weight')
g.V().outE().sample(2).by('weight').values('weight')

g.V(1).repeat(local(
         bothE().sample(1).by('weight').otherV()
       )).times(5)
g.V(1).repeat(local(
         bothE().sample(1).by('weight').otherV()
       )).times(5).path()
g.V(1).repeat(local(
         bothE().sample(1).by('weight').otherV()
       )).times(10).path()

g.V().repeat(bothE().sample(1).by('weight').otherV()).times(5).path()

g.V().repeat(local(bothE().sample(1).by('weight').otherV())).times(5).path()

g.V().as('a').out().as('b').out().as('c') // no select
g.V().as('a').out().as('b').out().as('c').select('a','b','c')
g.V().as('a').out().as('b').out().as('c').select('a','b')
g.V().as('a').out().as('b').out().as('c').select('a','b').by('name')
g.V().as('a').out().as('b').out().as('c').select('a') (1)

g.V().out().out()
g.V().out().out().path()
g.V().as('x').out().out().select('x')
g.V().out().as('x').out().select('x')
g.V().out().out().as('x').select('x') // pointless

g = graph.traversal()
g.io('data/grateful-dead.xml').read().iterate()
g.V().hasLabel('song').out('followedBy').groupCount().by('name').
      order(local).by(values,desc).limit(local, 5)
g.V().hasLabel('song').out('followedBy').groupCount().by('name').
      order(local).by(values,desc).limit(local, 5).select(keys)
g.V().hasLabel('song').out('followedBy').groupCount().by('name').
      order(local).by(values,desc).limit(local, 5).select(keys).unfold()

g = graph.traversal()
g.io('data/grateful-dead.xml').read().iterate()
g.V().hasLabel('song').out('sungBy').groupCount().by('name') (1)
g.V().hasLabel('song').out('sungBy').groupCount().by('name').select(values) (2)
g.V().hasLabel('song').out('sungBy').groupCount().by('name').select(values).unfold().
      groupCount().order(local).by(values,desc).limit(local, 5) (3)

g.V(1).as("a").repeat(out().as("a")).times(2).select(first, "a")
g.V(1).as("a").repeat(out().as("a")).times(2).select(last, "a")
g.V(1).as("a").repeat(out().as("a")).times(2).select(all, "a")

g.withSideEffect("alias", ["marko":"okram"]).V().  (1)
  values("name").sack(assign).                     (2)
  optional(select("alias").select(sack()))         (3)

g = g.withComputer()
g.V().shortestPath() (1)
g.V().has('person','name','marko').shortestPath() (2)
g.V().shortestPath().with(ShortestPath.target, __.has('name','peter')) (3)
g.V().shortestPath().
        with(ShortestPath.edges, Direction.IN).
        with(ShortestPath.target, __.has('name','josh')) (4)
g.V().has('person','name','marko').
      shortestPath().
        with(ShortestPath.target, __.has('name','josh')) (5)
g.V().has('person','name','marko').
      shortestPath().
        with(ShortestPath.target, __.has('name','josh')).
        with(ShortestPath.distance, 'weight') (6)
g.V().has('person','name','marko').
      shortestPath().
        with(ShortestPath.target, __.has('name','josh')).
        with(ShortestPath.includeEdges, true) (7)

g.inject(g.withComputer().V().shortestPath().
           with(ShortestPath.distance, 'weight').
           with(ShortestPath.includeEdges, true).
           with(ShortestPath.maxDistance, 1).toList().toArray()).
  map(unfold().values('name','weight').fold()) (1)

g.V(1).both().both()
g.V(1).both().both().simplePath()
g.V(1).both().both().simplePath().path()
g.V().out().as('a').out().as('b').out().as('c').
  simplePath().by(label).
  path()
g.V().out().as('a').out().as('b').out().as('c').
  simplePath().
    by(label).
    from('b').
    to('c').
  path().
    by('name')

g.addV().property(id, 'A').as('a').
  addV().property(id, 'B').as('b').
  addV().property(id, 'C').as('c').
  addV().property(id, 'D').as('d').
  addE('link').from('a').to('b').
  addE('link').from('b').to('c').
  addE('link').from('c').to('d').iterate()
g.V('A').repeat(both().simplePath()).times(3).path()  (1)
g.V('D').repeat(both().simplePath()).times(3).path()  (2)
g.V('A').as('a').
  repeat(both().simplePath().from('a')).times(3).as('b').
  repeat(both().simplePath().from('b')).times(3).path()  (3)

g.V().values('age').order()
g.V().values('age').order().skip(2)
g.V().values('age').order().range(2, -1)

g.V().hasLabel('person').filter(outE('created')).as('p'). (1)
  map(out('created').values('name').fold()).
  project('person','primary','other').
    by(select('p').by('name')).
    by(limit(local, 1)). (2)
    by(skip(local, 1)) (3)

g.V().aggregate('x').limit(1).cap('x')
g.V().store('x').limit(1).cap('x')

g.E().store('x').by('weight').cap('x')

subGraph = g.E().hasLabel('knows').subgraph('subGraph').cap('subGraph').next() (1)
sg = subGraph.traversal()
sg.E() (2)

subGraph = g.V(3).repeat(__.inE().subgraph('subGraph').outV()).times(3).cap('subGraph').next()  (1)
sg = subGraph.traversal()
sg.E()

t = g.V().outE('knows').subgraph('knowsG').inV().outE('created').subgraph('createdG').
          inV().inE('created').subgraph('createdG').iterate()
t.sideEffects.get('knowsG').traversal().E()
t.sideEffects.get('createdG').traversal().E()

Vertex v = sg.V().has('name','marko').next();  (1)
List<Vertex> vertices = g.V(v).out().toList(); (2)

Vertex v = sg.V().has('name','marko').next();
List<Vertex> vertices = g.V(v.id()).out().toList();

// OR

Vertex v = new ReferenceVertex(sg.V().has('name','marko').next());
List<Vertex> vertices = g.V(v).out().toList();

g.V().values('age').sum()
g.V().repeat(both()).times(3).values('age').sum()

g.V().values('name').order()
g.V().values('name').order().tail() (1)
g.V().values('name').order().tail(1) (2)
g.V().values('name').order().tail(3) (3)

g.V().as('a').out().as('a').out().as('a').select('a').by(tail(local)).values('name') (1)
g.V().as('a').out().as('a').out().as('a').select('a').by(unfold().values('name').fold()).tail(local) (2)
g.V().as('a').out().as('a').out().as('a').select('a').by(unfold().values('name').fold()).tail(local, 2) (3)
g.V().valueMap().tail(local) (4)

g.V().repeat(both().groupCount('m')).times(16).cap('m').order(local).by(values,desc).next()
clock(1) {g.V().repeat(both().groupCount('m')).times(16).cap('m').order(local).by(values,desc).next()}
g.V().repeat(timeLimit(2).both().groupCount('m')).times(16).cap('m').order(local).by(values,desc).next()
clock(1) {g.V().repeat(timeLimit(2).both().groupCount('m')).times(16).cap('m').order(local).by(values,desc).next()}

tree = g.V().out().out().tree().next()

tree = g.V().out().out().tree().by('name').next()
tree['marko']
tree['marko']['josh']
tree.getObjectsAtDepth(3)

g.V().has('name','josh').out('created').values('name').tree() (1)
g.V().has('name','josh').out('created').values('name').
  tree().by('name').by(label).by() (2)

g.V(1).out().fold().inject('gremlin',[1.23,2.34])
g.V(1).out().fold().inject('gremlin',[1.23,2.34]).unfold()

inject(1,[2,3,[4,5,[6]]])
inject(1,[2,3,[4,5,[6]]]).unfold()
inject(1,[2,3,[4,5,[6]]]).repeat(unfold()).until(count(local).is(1)).unfold()

g.V(4).union(
         __.in().values('age'),
         out().values('lang'))
g.V(4).union(
         __.in().values('age'),
         out().values('lang')).path()

g.V(1).properties().value()
g.V(1).properties().properties().value()

g.V().valueMap()
g.V().valueMap('age')
g.V().valueMap('age','blah')
g.E().valueMap()

g.V().valueMap()
g.V().has('name','marko').properties('location')
g.V().has('name','marko').properties('location').valueMap()

g.V().valueMap().by(unfold())
g.V().valueMap('name','location').by().by(unfold())

g.V().hasLabel('person').valueMap().with(WithOptions.tokens)
g.V().hasLabel('person').valueMap('name').with(WithOptions.tokens, WithOptions.labels)
g.V().hasLabel('person').properties('location').valueMap().with(WithOptions.tokens, WithOptions.values)

g.V(1).values()
g.V(1).values('location')
g.V(1).properties('location').values()

g.V(4)
g.V(4).outE() (1)
g.V(4).inE('knows') (2)
g.V(4).inE('created') (3)
g.V(4).bothE('knows','created','blah')
g.V(4).bothE('knows','created','blah').otherV()
g.V(4).both('knows','created','blah')
g.V(4).outE().inV() (4)
g.V(4).out() (5)
g.V(4).inE().outV()
g.V(4).inE().bothV()

g.V(1).as('a').out('created').in('created').where(neq('a')) (1)
g.withSideEffect('a',['josh','peter']).V(1).out('created').in('created').values('name').where(within('a')) (2)
g.V(1).out('created').in('created').where(out('created').count().is(gt(1))).values('name') (3)

g.V().where(out('created')).values('name') (1)
g.V().out('knows').where(out('created')).values('name') (2)
g.V().where(out('created').count().is(gte(2))).values('name') (3)
g.V().where(out('knows').where(out('created'))).values('name') (4)
g.V().where(__.not(out('created'))).where(__.in('knows')).values('name') (5)
g.V().where(__.not(out('created')).and().in('knows')).values('name') (6)
g.V().as('a').out('knows').as('b').
  where('a',gt('b')).
    by('age').
  select('a','b').
    by('name') (7)
g.V().as('a').out('knows').as('b').
  where('a',gt('b').or(eq('b'))).
    by('age').
    by('age').
    by(__.in('knows').values('age')).
  select('a','b').
    by('name') (8)

g = TinkerGraph.open().traversal()
v = g.addV().property(id,'42a').next()
g.V('42a')

graph = Neo4jGraph.open('/tmp/neo4j')
strategy = ElementIdStrategy.build().create()
g = graph.traversal().withStrategies(strategy)
g.addV().property(id, '42a').id()

import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.*
graph = TinkerFactory.createModern()
l = new ConsoleMutationListener(graph)
strategy = EventStrategy.build().addListener(l).create()
g = graph.traversal().withStrategies(strategy)
g.addV().property('name','stephen')
g.E().drop()

graph = TinkerFactory.createModern()
strategyA = PartitionStrategy.build().partitionKey("_partition").writePartition("a").readPartitions("a").create()
strategyB = PartitionStrategy.build().partitionKey("_partition").writePartition("b").readPartitions("b").create()
gA = graph.traversal().withStrategies(strategyA)
gA.addV() // this vertex has a property of {_partition:"a"}
gB = graph.traversal().withStrategies(strategyB)
gB.addV() // this vertex has a property of {_partition:"b"}
gA.V()
gB.V()

graph = TinkerFactory.createTheCrew()
g = graph.traversal()
g.V().as('a').values('location').as('b').  (1)
  select('a','b').by('name').by()
g = g.withStrategies(SubgraphStrategy.build().vertexProperties(hasNot('endTime')).create()) (2)
g.V().as('a').values('location').as('b').  (3)
  select('a','b').by('name').by()
g.V().as('a').values('location').as('b').
  select('a','b').by('name').by().explain()

graph = TinkerFactory.createTheCrew()
g = graph.traversal().withStrategies(SubgraphStrategy.build().
  vertices(or(hasNot('location'),properties('location').count().is(gt(3)))).
  edges(hasLabel('develops')).
  vertexProperties(or(hasLabel(neq('location')),hasNot('endTime'))).create())
g.V().valueMap().with(WithOptions.tokens)
g.E().valueMap().with(WithOptions.tokens)
g.V().outE().inV().
  path().
    by('name').
    by().
    by('name')