remove traversal compat (#374)

* improve compat

* more compat improvements

Author: bbrehm

traversal/src/main/scala/overflowdb/traversal/Implicits.scala

@@ -7,22 +7,31 @@ trait Implicits {
   type Traversal[+A] = Iterator[A]
   implicit def jIteratortoTraversal[A](jiterator: java.util.Iterator[A]): Iterator[A] = jiterator.asScala
 
-  implicit def toTraversalSugarExt[A](iter: Iterator[A]): TraversalSugarExt[A] = new TraversalSugarExt(iter)
-  implicit def toTraversalLogicExt[A](iter: Iterator[A]): TraversalLogicExt[A] = new TraversalLogicExt(iter)
-  implicit def toTraversalFilterExt[A](iter: Iterator[A]): TraversalFilterExt[A] = new TraversalFilterExt(iter)
-
-  implicit def toTraversalTrackingExt[A](iter: Iterator[A]): TraversalTrackingExt[A] = new TraversalTrackingExt(iter)
-  implicit def toRepeatTraversalExt[A](iter: Iterator[A]): TraversalRepeatExt[A] = new TraversalRepeatExt(iter)
-
-  implicit def iterableToTraversal[A](iterable: IterableOnce[A]): Iterator[A] = iterable.iterator
-  implicit def toNodeTraversal[A <: Node](traversal: Iterator[A]): NodeTraversal[A] =
-    new NodeTraversal[A](traversal)
-
-  implicit def toEdgeTraversal[A <: Edge](traversal: Iterator[A]): EdgeTraversal[A] =
-    new EdgeTraversal[A](traversal)
-
-  implicit def toElementTraversal[A <: Element](traversal: Iterator[A]): ElementTraversal[A] =
-    new ElementTraversal[A](traversal)
+  implicit def toTraversalSugarExt[A](iter: IterableOnce[A]): TraversalSugarExt[A] = new TraversalSugarExt(
+    iter.iterator
+  )
+  implicit def toTraversalLogicExt[A](iter: IterableOnce[A]): TraversalLogicExt[A] = new TraversalLogicExt(
+    iter.iterator
+  )
+  implicit def toTraversalFilterExt[A](iter: IterableOnce[A]): TraversalFilterExt[A] = new TraversalFilterExt(
+    iter.iterator
+  )
+
+  implicit def toTraversalTrackingExt[A](iter: IterableOnce[A]): TraversalTrackingExt[A] = new TraversalTrackingExt(
+    iter.iterator
+  )
+  implicit def toRepeatTraversalExt[A](iter: IterableOnce[A]): TraversalRepeatExt[A] = new TraversalRepeatExt(
+    iter.iterator
+  )
+
+  implicit def toNodeTraversal[A <: Node](traversal: IterableOnce[A]): NodeTraversal[A] =
+    new NodeTraversal[A](traversal.iterator)
+
+  implicit def toEdgeTraversal[A <: Edge](traversal: IterableOnce[A]): EdgeTraversal[A] =
+    new EdgeTraversal[A](traversal.iterator)
+
+  implicit def toElementTraversal[A <: Element](traversal: IterableOnce[A]): ElementTraversal[A] =
+    new ElementTraversal[A](traversal.iterator)
 
   implicit def toNodeOps[N <: Node](node: N): NodeOps[N] = new NodeOps(node)
 

traversal/src/main/scala/overflowdb/traversal/Traversal.scala

@@ -16,40 +16,64 @@ import scala.collection.immutable.ArraySeq
 import scala.jdk.CollectionConverters._
 import scala.reflect.ClassTag
 
-class TraversalSugarExt[A](val iterator: Iterator[A]) extends AnyVal {
+class TraversalSugarExt[A](val iter: Iterator[A]) extends AnyVal {
   type Traversal[A] = Iterator[A]
 
   /** Execute the traversal and convert the result to a list - shorthand for `toList` */
   @Doc(info = "Execute the traversal and convert the result to a list - shorthand for `toList`")
-  def l: List[A] = iterator.toList
+  def l: List[A] = iter.toList
+
+  /** group elements and count how often they appear */
+  @Doc(info = "group elements and count how often they appear")
+  def groupCount[B >: A]: Map[B, Int] =
+    groupCount(identity[A])
+
+  /** group elements by a given transformation function and count how often the results appear */
+  @Doc(info = "group elements by a given transformation function and count how often the results appear")
+  def groupCount[B](by: A => B): Map[B, Int] = {
+    val counts = mutable.Map.empty[B, Int].withDefaultValue(0)
+    iter.foreach { a =>
+      val b = by(a)
+      val newValue = counts(b) + 1
+      counts.update(b, newValue)
+    }
+    counts.to(Map)
+  }
+
+  def groupBy[K](f: A => K): Map[K, List[A]] = l.groupBy(f)
+  def groupMap[K, B](key: A => K)(f: A => B): Map[K, List[B]] = l.groupMap(key)(f)
+  def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B] = l.groupMapReduce(key)(f)(reduce)
+
+  /** Execute the traversal and return a mutable.Set (better performance than `immutableSet` and has stable iterator
+    * order)
+    */
+  def toSetMutable[B >: A]: mutable.LinkedHashSet[B] = mutable.LinkedHashSet.from(iter)
 
-  /** Execute the traversal and return a mutable.Set (better performance than `immutableSet`) */
-  def toSetMutable[B >: A]: mutable.Set[B] = mutable.Set.from(iterator)
+  /** Execute the traversal and convert the result to an immutable Set. */
 
-  /** Execute the traversal and convert the result to an immutable Set */
-  def toSetImmutable[B >: A]: Set[B] = iterator.toSet
+  def toSetImmutable[B >: A]: Set[B] = iter.toSet
 
   /** Execute the traversal without returning anything */
   @Doc(info = "Execute the traversal without returning anything")
   def iterate(): Unit =
-    while (iterator.hasNext) iterator.next()
+    while (iter.hasNext) iter.next()
 
   def countTrav: Traversal[Int] =
-    Iterator.single(iterator.size)
+    Iterator.single(iter.size)
 
-  def head: A = iterator.next()
+  def head: A = iter.next()
 
-  def headOption: Option[A] = iterator.nextOption()
+  def headOption: Option[A] = iter.nextOption()
 
   def last: A = {
-    iterator.hasNext
-    var res = iterator.next()
-    while (iterator.hasNext) res = iterator.next()
+    iter.hasNext
+    var res = iter.next()
+    while (iter.hasNext) res = iter.next()
     res
   }
 
   def lastOption: Option[A] =
-    if (iterator.hasNext) Some(last) else None
+    if (iter.hasNext) Some(last) else None
 
   /** casts all elements to given type note: this can lead to casting errors
     *
@@ -58,33 +82,33 @@ class TraversalSugarExt[A](val iterator: Iterator[A]) extends AnyVal {
     */
   @Doc(info = "casts all elements to given type")
   def cast[B]: Traversal[B] =
-    iterator.asInstanceOf[Traversal[B]]
+    iter.asInstanceOf[Traversal[B]]
 
   /** collects all elements of the given class (beware of type-erasure) */
   @Doc(info = "collects all elements of the provided class (beware of type-erasure)")
   def collectAll[B](implicit ev: ClassTag[B]): Traversal[B] =
-    iterator.filter(ev.runtimeClass.isInstance).asInstanceOf[Traversal[B]]
+    iter.filter(ev.runtimeClass.isInstance).asInstanceOf[Traversal[B]]
 
   /** Deduplicate elements of this traversal - a.k.a. distinct, unique, ... */
   @Doc(info = "deduplicate elements of this traversal - a.k.a. distinct, unique, ...")
   def dedup: Traversal[A] =
-    iterator.distinct
+    iter.distinct
 
   /** deduplicate elements of this traversal by a given function */
   @Doc(info = "deduplicate elements of this traversal by a given function")
   def dedupBy(fun: A => Any): Traversal[A] =
-    iterator.distinctBy(fun)
+    iter.distinctBy(fun)
 
   /** sort elements by their natural order */
   @Doc(info = "sort elements by their natural order")
   def sorted[B >: A](implicit ord: Ordering[B]): Seq[B] = {
-    (iterator.to(ArraySeq.untagged): ArraySeq[B]).sorted
+    (iter.to(ArraySeq.untagged): ArraySeq[B]).sorted
   }
 
   /** sort elements by the value of the given transformation function */
   @Doc(info = "sort elements by the value of the given transformation function")
   def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Seq[A] =
-    iterator.to(ArraySeq.untagged).sortBy(f)
+    iter.to(ArraySeq.untagged).sortBy(f)
 
   /** Print help/documentation based on the current elementType `A`. Relies on all step extensions being annotated with
     * \@Traversal / @Doc Note that this works independently of tab completion and implicit conversions in scope - it

traversal/src/main/scala/overflowdb/traversal/TraversalSource.scala

@@ -17,13 +17,13 @@ class TraversalSource(graph: Graph) {
     graph.nodes(ids: _*).asScala.asInstanceOf[Traversal[NodeType]]
 
   def label(label: String): Traversal[Node] =
-    graph.nodes(label).asScala
+    this.labelTyped[Node](label)
 
   def hasLabel(label: String): Traversal[Node] =
-    this.label(label)
+    this.labelTyped[Node](label)
 
   def labelTyped[A <: Node](label: String): Traversal[A] =
-    this.label(label).asInstanceOf[Traversal[A]]
+    InitialTraversal.from[A](graph, label)
 
   /** Start traversal with all nodes that have given property value */
   def has(property: Property[_]): Traversal[Node] = {

traversal/src/main/scala/overflowdb/traversal/package.scala

@@ -10,7 +10,7 @@ package object traversal extends Implicits {
       * method calls and a `match` without @switch 2) no additional `map` step that iterates and creates yet another
       * iterator
       */
-    def toScalaAs[B]: IterableOnce[B] =
+    def toScalaAs[B]: Iterator[B] =
       new JIteratorCastingWrapper[B](jIterator)
   }