Basic implementation of Cypher head() function

testware/integration-tests/src/test/java/org/opencypher/gremlin/queries/FunctionTest.java

@@ -165,6 +165,17 @@ public void sizeOfPatternExpressionInReturn() {
             .containsExactly(2L);
     }
 
+    @Test
+    public void head() {
+        String cypher = "MATCH (n:person) WITH n.name AS name " +
+            "ORDER BY name RETURN head(collect(name)) AS head";
+        List<Map<String, Object>> results = submitAndGet(cypher);
+
+        assertThat(results)
+            .extracting("head")
+            .containsExactly("josh");
+    }
+
     @Test
     public void sizeOfPatternExpressionInWhere() {
         String cypher = "MATCH (n:person) WHERE size( (n)-->() ) > 1 RETURN n.name";

translation/src/main/java/org/opencypher/gremlin/translation/GremlinSteps.java

@@ -137,6 +137,8 @@ GremlinSteps<T, P> choose(GremlinSteps<T, P> traversalPredicate,
 
     GremlinSteps<T, P> limit(long limit);
 
+    GremlinSteps<T, P> limit(Scope scope, long limit);
+
     GremlinSteps<T, P> local(GremlinSteps<T, P> localTraversal);
 
     GremlinSteps<T, P> loops();

translation/src/main/java/org/opencypher/gremlin/translation/bytecode/BytecodeGremlinSteps.java

@@ -299,6 +299,12 @@ public GremlinSteps<Bytecode, P> limit(long limit) {
         return this;
     }
 
+    @Override
+    public GremlinSteps<Bytecode, P> limit(Scope scope, long limit) {
+        bytecode.addStep(Symbols.limit, scope, limit);
+        return this;
+    }
+
     @Override
     public GremlinSteps<Bytecode, P> local(GremlinSteps<Bytecode, P> localTraversal) {
         bytecode.addStep(Symbols.local, localTraversal.current());

translation/src/main/java/org/opencypher/gremlin/translation/groovy/GroovyGremlinSteps.java

@@ -307,6 +307,12 @@ public GremlinSteps<String, GroovyPredicate> limit(long limit) {
         return this;
     }
 
+    @Override
+    public GremlinSteps<String, GroovyPredicate> limit(Scope scope, long limit) {
+        g.append(chain("limit", scope, limit));
+        return this;
+    }
+
     @Override
     public GremlinSteps<String, GroovyPredicate> local(GremlinSteps<String, GroovyPredicate> localTraversal) {
         g.append(chain("local", traversal(localTraversal)));

translation/src/main/java/org/opencypher/gremlin/translation/traversal/TraversalGremlinSteps.java

@@ -338,6 +338,12 @@ public GremlinSteps<GraphTraversal, P> limit(long limit) {
         return this;
     }
 
+    @Override
+    public GremlinSteps<GraphTraversal, P> limit(Scope scope, long limit) {
+        g.limit(scope, limit);
+        return this;
+    }
+
     @Override
     public GremlinSteps<GraphTraversal, P> local(GremlinSteps<GraphTraversal, P> localTraversal) {
         g.local(localTraversal.current());

translation/src/main/scala/org/opencypher/gremlin/translation/ir/TranslationWriter.scala

@@ -156,6 +156,8 @@ sealed class TranslationWriter[T, P] private (translator: Translator[T, P], para
           g.label()
         case Limit(limit) =>
           g.limit(limit)
+        case LimitS(scope, limit) =>
+          g.limit(scope, limit)
         case Local(traversal) =>
           g.local(writeLocalSteps(traversal))
         case Loops =>

translation/src/main/scala/org/opencypher/gremlin/translation/ir/builder/IRGremlinSteps.scala

@@ -254,6 +254,11 @@ class IRGremlinSteps extends GremlinSteps[Seq[GremlinStep], GremlinPredicate] {
     this
   }
 
+  override def limit(scope: Scope, limit: Long): GremlinSteps[Seq[GremlinStep], GremlinPredicate] = {
+    buf += LimitS(scope, limit)
+    this
+  }
+
   override def local(
       traversal: GremlinSteps[Seq[GremlinStep], GremlinPredicate]): GremlinSteps[Seq[GremlinStep], GremlinPredicate] = {
     buf += Local(traversal.current())

translation/src/main/scala/org/opencypher/gremlin/translation/ir/model/GremlinStep.scala

@@ -172,6 +172,8 @@ case object Label extends GremlinStep
 
 case class Limit(limit: Long) extends GremlinStep
 
+case class LimitS(scope: Scope, limit: Long) extends GremlinStep
+
 case class Local(traversal: Seq[GremlinStep]) extends GremlinStep {
   override def mapTraversals(f: Seq[GremlinStep] => Seq[GremlinStep]): GremlinStep = {
     Local(f(traversal))

translation/src/main/scala/org/opencypher/gremlin/translation/walker/ExpressionWalker.scala

@@ -209,6 +209,7 @@ private class ExpressionWalker[T, P](context: WalkerContext[T, P], g: GremlinSte
           case "abs"           => traversals.head.math("abs(_)")
           case "coalesce"      => __.coalesce(traversals.init.map(_.is(p.neq(NULL))) :+ traversals.last: _*)
           case "exists"        => traversals.head.flatMap(anyMatch(__.is(p.neq(NULL))))
+          case "head"          => traversals.head.flatMap(notNull(__.limit(Scope.local, 1), context))
           case "id"            => traversals.head.flatMap(notNull(__.id(), context))
           case "keys"          => traversals.head.properties().key().fold()
           case "labels"        => traversals.head.label().is(p.neq(Vertex.DEFAULT_LABEL)).fold()