rename OSet -> Agg

9 files changed, 72 insertions, 72 deletions

diff --git a/core/src/main/scala/mill/define/Graph.scala b/core/src/main/scala/mill/define/Graph.scala
index 68fb65ed..f06dca11 100644
--- a/core/src/main/scala/mill/define/Graph.scala
+++ b/core/src/main/scala/mill/define/Graph.scala
@@ -2,17 +2,17 @@ package mill.define
 
 import mill.eval.Tarjans
 import mill.util.MultiBiMap
-import mill.util.Strict.OSet
+import mill.util.Strict.Agg
 
 object Graph {
-  class TopoSorted private[Graph](val values: OSet[Task[_]])
+  class TopoSorted private[Graph](val values: Agg[Task[_]])
   def groupAroundImportantTargets[T](topoSortedTargets: TopoSorted)
                                     (important: PartialFunction[Task[_], T]): MultiBiMap[T, Task[_]] = {
 
     val output = new MultiBiMap.Mutable[T, Task[_]]()
     for ((target, t) <- topoSortedTargets.values.flatMap(t => important.lift(t).map((t, _)))) {
 
-      val transitiveTargets = new OSet.Mutable[Task[_]]
+      val transitiveTargets = new Agg.Mutable[Task[_]]
       def rec(t: Task[_]): Unit = {
         if (transitiveTargets.contains(t)) () // do nothing
         else if (important.isDefinedAt(t) && t != target) () // do nothing
@@ -27,8 +27,8 @@ object Graph {
     output
   }
 
-  def transitiveTargets(sourceTargets: OSet[Task[_]]): OSet[Task[_]] = {
-    val transitiveTargets = new OSet.Mutable[Task[_]]
+  def transitiveTargets(sourceTargets: Agg[Task[_]]): Agg[Task[_]] = {
+    val transitiveTargets = new Agg.Mutable[Task[_]]
     def rec(t: Task[_]): Unit = {
       if (transitiveTargets.contains(t)) () // do nothing
       else {
@@ -44,7 +44,7 @@ object Graph {
     * Takes the given targets, finds all the targets they transitively depend
     * on, and sort them topologically. Fails if there are dependency cycles
     */
-  def topoSorted(transitiveTargets: OSet[Task[_]]): TopoSorted = {
+  def topoSorted(transitiveTargets: Agg[Task[_]]): TopoSorted = {
 
     val indexed = transitiveTargets.indexed
     val targetIndices = indexed.zipWithIndex.toMap
@@ -56,6 +56,6 @@ object Graph {
     val sortedClusters = Tarjans(numberedEdges)
     val nonTrivialClusters = sortedClusters.filter(_.length > 1)
     assert(nonTrivialClusters.isEmpty, nonTrivialClusters)
-    new TopoSorted(OSet.from(sortedClusters.flatten.map(indexed)))
+    new TopoSorted(Agg.from(sortedClusters.flatten.map(indexed)))
   }
 }
diff --git a/core/src/main/scala/mill/discover/Discovered.scala b/core/src/main/scala/mill/discover/Discovered.scala
index b7ec2140..98d4ebb9 100644
--- a/core/src/main/scala/mill/discover/Discovered.scala
+++ b/core/src/main/scala/mill/discover/Discovered.scala
@@ -5,7 +5,7 @@ import ammonite.main.Router
 import ammonite.main.Router.EntryPoint
 import mill.discover.Mirror.TargetPoint
 import mill.util.Ctx.Loader
-import mill.util.Strict.OSet
+import mill.util.Strict.Agg
 
 import scala.language.experimental.macros
 import scala.reflect.macros.blackbox.Context
@@ -28,7 +28,7 @@ object Discovered {
       (mirror, segments, resolvedNode) => Seq(resolvedNode -> mirror)
     }.toMap
 
-    val targets = OSet.from(
+    val targets = Agg.from(
       Mirror.traverseNode(base, mirror){ (mirror, segmentsRev, resolvedNode) =>
         for(target <- mirror.targets)
         yield target.asInstanceOf[TargetPoint[Any, Any]].run(resolvedNode)
@@ -44,7 +44,7 @@ object Discovered {
     val targetsToSegments = segmentsToTargets.map(_.swap)
   }
 
-  def consistencyCheck[T](mapping: Discovered.Mapping[T]): OSet[Segments] = {
+  def consistencyCheck[T](mapping: Discovered.Mapping[T]): Agg[Segments] = {
     val mapping2 = Discovered.Mapping(mapping.mirror, mapping.base)
     for{
       (t1, t2) <- mapping2.targets.zip(mapping.targets)
diff --git a/core/src/main/scala/mill/eval/Evaluator.scala b/core/src/main/scala/mill/eval/Evaluator.scala
index 2afaec6e..28d90fcf 100644
--- a/core/src/main/scala/mill/eval/Evaluator.scala
+++ b/core/src/main/scala/mill/eval/Evaluator.scala
@@ -9,7 +9,7 @@ import mill.discover.{Discovered, Mirror}
 import mill.define.Segment
 import mill.util
 import mill.util._
-import mill.util.Strict.OSet
+import mill.util.Strict.Agg
 
 import scala.collection.mutable
 import scala.util.control.NonFatal
@@ -35,7 +35,7 @@ class Evaluator[T](val workspacePath: Path,
 
   val workerCache = mutable.Map.empty[Ctx.Loader[_], Any]
   workerCache(Discovered.Mapping) = mapping
-  def evaluate(goals: OSet[Task[_]]): Evaluator.Results = {
+  def evaluate(goals: Agg[Task[_]]): Evaluator.Results = {
     mkdir(workspacePath)
 
     val transitive = Graph.transitiveTargets(goals)
@@ -55,7 +55,7 @@ class Evaluator[T](val workspacePath: Path,
       case t if goals.contains(t) => Left(t)
     }
 
-    val evaluated = new OSet.Mutable[Task[_]]
+    val evaluated = new Agg.Mutable[Task[_]]
     val results = mutable.LinkedHashMap.empty[Task[_], Result[Any]]
 
     for (((terminal, group), i) <- sortedGroups.items().zipWithIndex){
@@ -84,7 +84,7 @@ class Evaluator[T](val workspacePath: Path,
 
 
   def evaluateGroupCached(terminal: Either[Task[_], Labelled[_]],
-                          group: OSet[Task[_]],
+                          group: Agg[Task[_]],
                           results: collection.Map[Task[_], Result[Any]],
                           counterMsg: String): (collection.Map[Task[_], Result[Any]], Seq[Task[_]]) = {
 
@@ -168,7 +168,7 @@ class Evaluator[T](val workspacePath: Path,
   }
 
 
-  def evaluateGroup(group: OSet[Task[_]],
+  def evaluateGroup(group: Agg[Task[_]],
                     results: collection.Map[Task[_], Result[Any]],
                     groupBasePath: Option[Path],
                     paths: Option[Evaluator.Paths],
@@ -275,8 +275,8 @@ object Evaluator{
 
   }
   case class Results(rawValues: Seq[Result[Any]],
-                     evaluated: OSet[Task[_]],
-                     transitive: OSet[Task[_]],
+                     evaluated: Agg[Task[_]],
+                     transitive: Agg[Task[_]],
                      failing: MultiBiMap[Either[Task[_], Labelled[_]], Result.Failing],
                      results: collection.Map[Task[_], Result[Any]]){
     def values = rawValues.collect{case Result.Success(v) => v}
diff --git a/core/src/main/scala/mill/main/ReplApplyHandler.scala b/core/src/main/scala/mill/main/ReplApplyHandler.scala
index b83453ee..c239745a 100644
--- a/core/src/main/scala/mill/main/ReplApplyHandler.scala
+++ b/core/src/main/scala/mill/main/ReplApplyHandler.scala
@@ -5,7 +5,7 @@ import mill.define.Applicative.ApplyHandler
 import mill.define._
 import mill.discover.{Discovered, Mirror}
 import mill.eval.{Evaluator, Result}
-import mill.util.Strict.OSet
+import mill.util.Strict.Agg
 
 import scala.collection.mutable
 object ReplApplyHandler{
@@ -34,7 +34,7 @@ class ReplApplyHandler(pprinter0: pprint.PPrinter, evaluator: Evaluator[_]) exte
   // as the user enters more REPL commands and changes the classpath
   val classLoaderSig = Evaluator.classLoaderSig
   override def apply[V](t: Task[V]) = {
-    val res = evaluator.evaluate(OSet(t))
+    val res = evaluator.evaluate(Agg(t))
     res.values match{
       case Seq(head: V) => head
       case Nil =>
diff --git a/core/src/main/scala/mill/main/RunScript.scala b/core/src/main/scala/mill/main/RunScript.scala
index 9f73fbc8..785db80e 100644
--- a/core/src/main/scala/mill/main/RunScript.scala
+++ b/core/src/main/scala/mill/main/RunScript.scala
@@ -12,7 +12,7 @@ import mill.define.Segment
 import mill.discover.Discovered
 import mill.eval.{Evaluator, Result}
 import mill.util.{EitherOps, Logger}
-import mill.util.Strict.OSet
+import mill.util.Strict.Agg
 import upickle.Js
 
 /**
@@ -138,7 +138,7 @@ object RunScript{
 
   def evaluate(evaluator: Evaluator[_],
                targets: Seq[Task[Any]]): (Seq[PathRef], Either[String, Seq[(Any, Option[upickle.Js.Value])]]) = {
-    val evaluated = evaluator.evaluate(OSet.from(targets))
+    val evaluated = evaluator.evaluate(Agg.from(targets))
     val watched = evaluated.results
       .iterator
       .collect {
diff --git a/core/src/main/scala/mill/modules/Jvm.scala b/core/src/main/scala/mill/modules/Jvm.scala
index 6e3fe45f..48f100b2 100644
--- a/core/src/main/scala/mill/modules/Jvm.scala
+++ b/core/src/main/scala/mill/modules/Jvm.scala
@@ -9,15 +9,15 @@ import ammonite.ops._
 import mill.define.Task
 import mill.eval.PathRef
 import mill.util.Ctx
-import mill.util.Loose.OSet
+import mill.util.Loose.Agg
 
 import scala.annotation.tailrec
 import scala.collection.mutable
 
 
 object Jvm {
-  def gatherClassloaderJars(): OSet[Path] = {
-    val allJars = new OSet.Mutable[Path]()
+  def gatherClassloaderJars(): Agg[Path] = {
+    val allJars = new Agg.Mutable[Path]()
     var currentClassloader = Thread.currentThread().getContextClassLoader
     while(currentClassloader != null){
       currentClassloader match{
@@ -30,14 +30,14 @@ object Jvm {
   }
 
   def interactiveSubprocess(mainClass: String,
-                            classPath: OSet[Path],
+                            classPath: Agg[Path],
                             options: Seq[String] = Seq.empty): Unit = {
     import ammonite.ops.ImplicitWd._
     %("java", "-cp", classPath.mkString(":"), mainClass, options)
   }
 
   def subprocess(mainClass: String,
-                 classPath: OSet[Path],
+                 classPath: Agg[Path],
                  jvmOptions: Seq[String] = Seq.empty,
                  options: Seq[String] = Seq.empty,
                  workingDir: Path = null)
@@ -101,7 +101,7 @@ object Jvm {
     m
   }
 
-  def createJar(inputPaths: OSet[Path], mainClass: Option[String] = None)
+  def createJar(inputPaths: Agg[Path], mainClass: Option[String] = None)
                (implicit ctx: Ctx.DestCtx): PathRef = {
     val outputPath = ctx.dest
     rm(outputPath)
@@ -135,7 +135,7 @@ object Jvm {
     PathRef(outputPath)
   }
 
-  def createAssembly(inputPaths: OSet[Path],
+  def createAssembly(inputPaths: Agg[Path],
                      mainClass: Option[String] = None,
                      prependShellScript: String = "")
                     (implicit ctx: Ctx.DestCtx): PathRef = {
diff --git a/core/src/main/scala/mill/package.scala b/core/src/main/scala/mill/package.scala
index 0b4f4873..78233cad 100644
--- a/core/src/main/scala/mill/package.scala
+++ b/core/src/main/scala/mill/package.scala
@@ -8,6 +8,6 @@ package object mill extends JsonFormatters{
   type Module = define.Module
   val Module = define.Module
   type Cross[T] = define.Cross[T]
-  type OSet[T] = util.Loose.OSet[T]
-  val OSet = util.Loose.OSet
+  type Agg[T] = util.Loose.Agg[T]
+  val Agg = util.Loose.Agg
 }
diff --git a/core/src/main/scala/mill/util/MultiBiMap.scala b/core/src/main/scala/mill/util/MultiBiMap.scala
index abbaa752..2cb81944 100644
--- a/core/src/main/scala/mill/util/MultiBiMap.scala
+++ b/core/src/main/scala/mill/util/MultiBiMap.scala
@@ -1,7 +1,7 @@
 package mill.util
 
 import scala.collection.mutable
-import Strict.OSet
+import Strict.Agg
 /**
   * A map from keys to collections of values: you can assign multiple values
   * to any particular key. Also allows lookups in both directions: what values
@@ -9,22 +9,22 @@ import Strict.OSet
   */
 trait MultiBiMap[K, V]{
   def containsValue(v: V): Boolean
-  def lookupKey(k: K): OSet[V]
+  def lookupKey(k: K): Agg[V]
   def lookupValue(v: V): K
   def lookupValueOpt(v: V): Option[K]
   def add(k: K, v: V): Unit
-  def removeAll(k: K): OSet[V]
+  def removeAll(k: K): Agg[V]
   def addAll(k: K, vs: TraversableOnce[V]): Unit
   def keys(): Iterator[K]
-  def items(): Iterator[(K, OSet[V])]
-  def values(): Iterator[OSet[V]]
+  def items(): Iterator[(K, Agg[V])]
+  def values(): Iterator[Agg[V]]
   def keyCount: Int
 }
 
 object MultiBiMap{
   class Mutable[K, V]() extends MultiBiMap[K, V]{
     private[this] val valueToKey = mutable.LinkedHashMap.empty[V, K]
-    private[this] val keyToValues = mutable.LinkedHashMap.empty[K, OSet.Mutable[V]]
+    private[this] val keyToValues = mutable.LinkedHashMap.empty[K, Agg.Mutable[V]]
     def containsValue(v: V) = valueToKey.contains(v)
     def lookupKey(k: K) = keyToValues(k)
     def lookupKeyOpt(k: K) = keyToValues.get(k)
@@ -32,10 +32,10 @@ object MultiBiMap{
     def lookupValueOpt(v: V) = valueToKey.get(v)
     def add(k: K, v: V): Unit = {
       valueToKey(v) = k
-      keyToValues.getOrElseUpdate(k, new OSet.Mutable[V]()).append(v)
+      keyToValues.getOrElseUpdate(k, new Agg.Mutable[V]()).append(v)
     }
-    def removeAll(k: K): OSet[V] = keyToValues.get(k) match {
-      case None => OSet()
+    def removeAll(k: K): Agg[V] = keyToValues.get(k) match {
+      case None => Agg()
       case Some(vs) =>
         vs.foreach(valueToKey.remove)
 
diff --git a/core/src/main/scala/mill/util/OSet.scala b/core/src/main/scala/mill/util/OSet.scala
index a4fcc406..d0f41777 100644
--- a/core/src/main/scala/mill/util/OSet.scala
+++ b/core/src/main/scala/mill/util/OSet.scala
@@ -3,46 +3,46 @@ package mill.util
 
 
 import scala.collection.mutable
-object Strict extends OSetWrapper(true)
-object Loose extends OSetWrapper(false)
-sealed class OSetWrapper(strictUniqueness: Boolean){
+object Strict extends AggWrapper(true)
+object Loose extends AggWrapper(false)
+sealed class AggWrapper(strictUniqueness: Boolean){
   /**
     * A collection with enforced uniqueness, fast contains and deterministic
     * ordering. Raises an exception if a duplicate is found; call
     * `toSeq.distinct` if you explicitly want to make it swallow duplicates
     */
-  trait OSet[V] extends TraversableOnce[V]{
+  trait Agg[V] extends TraversableOnce[V]{
     def contains(v: V): Boolean
     def items: Iterator[V]
     def indexed: IndexedSeq[V]
-    def flatMap[T](f: V => TraversableOnce[T]): OSet[T]
-    def map[T](f: V => T): OSet[T]
-    def filter(f: V => Boolean): OSet[V]
-    def withFilter(f: V => Boolean): OSet[V]
-    def collect[T](f: PartialFunction[V, T]): OSet[T]
-    def zipWithIndex: OSet[(V, Int)]
-    def reverse: OSet[V]
-    def zip[T](other: OSet[T]): OSet[(V, T)]
-    def ++[T >: V](other: TraversableOnce[T]): OSet[T]
+    def flatMap[T](f: V => TraversableOnce[T]): Agg[T]
+    def map[T](f: V => T): Agg[T]
+    def filter(f: V => Boolean): Agg[V]
+    def withFilter(f: V => Boolean): Agg[V]
+    def collect[T](f: PartialFunction[V, T]): Agg[T]
+    def zipWithIndex: Agg[(V, Int)]
+    def reverse: Agg[V]
+    def zip[T](other: Agg[T]): Agg[(V, T)]
+    def ++[T >: V](other: TraversableOnce[T]): Agg[T]
   }
 
-  object OSet{
-    def empty[V]: OSet[V] = new OSet.Mutable[V]
-    implicit def jsonFormat[T: upickle.default.ReadWriter]: upickle.default.ReadWriter[OSet[T]] =
-      upickle.default.ReadWriter[OSet[T]] (
+  object Agg{
+    def empty[V]: Agg[V] = new Agg.Mutable[V]
+    implicit def jsonFormat[T: upickle.default.ReadWriter]: upickle.default.ReadWriter[Agg[T]] =
+      upickle.default.ReadWriter[Agg[T]] (
         oset => upickle.default.writeJs(oset.toList),
-        {case json => OSet.from(upickle.default.readJs[Seq[T]](json))}
+        {case json => Agg.from(upickle.default.readJs[Seq[T]](json))}
       )
     def apply[V](items: V*) = from(items)
 
-    def from[V](items: TraversableOnce[V]): OSet[V] = {
-      val set = new OSet.Mutable[V]()
+    def from[V](items: TraversableOnce[V]): Agg[V] = {
+      val set = new Agg.Mutable[V]()
       items.foreach(set.append)
       set
     }
 
 
-    class Mutable[V]() extends OSet[V]{
+    class Mutable[V]() extends Agg[V]{
 
       private[this] val set0 = mutable.LinkedHashSet.empty[V]
       def contains(v: V) = set0.contains(v)
@@ -57,22 +57,22 @@ sealed class OSetWrapper(strictUniqueness: Boolean){
       def indexed: IndexedSeq[V] = items.toIndexedSeq
       def set: collection.Set[V] = set0
 
-      def map[T](f: V => T): OSet[T] = {
-        val output = new OSet.Mutable[T]
+      def map[T](f: V => T): Agg[T] = {
+        val output = new Agg.Mutable[T]
         for(i <- items) output.append(f(i))
         output
       }
-      def flatMap[T](f: V => TraversableOnce[T]): OSet[T] = {
-        val output = new OSet.Mutable[T]
+      def flatMap[T](f: V => TraversableOnce[T]): Agg[T] = {
+        val output = new Agg.Mutable[T]
         for(i <- items) for(i0 <- f(i)) output.append(i0)
         output
       }
-      def filter(f: V => Boolean): OSet[V] = {
-        val output = new OSet.Mutable[V]
+      def filter(f: V => Boolean): Agg[V] = {
+        val output = new Agg.Mutable[V]
         for(i <- items) if (f(i)) output.append(i)
         output
       }
-      def withFilter(f: V => Boolean): OSet[V] = filter(f)
+      def withFilter(f: V => Boolean): Agg[V] = filter(f)
 
       def collect[T](f: PartialFunction[V, T]) = this.filter(f.isDefinedAt).map(x => f(x))
 
@@ -84,10 +84,10 @@ sealed class OSetWrapper(strictUniqueness: Boolean){
         }
       }
 
-      def reverse = OSet.from(indexed.reverseIterator)
+      def reverse = Agg.from(indexed.reverseIterator)
 
-      def zip[T](other: OSet[T]) = OSet.from(items.zip(other.items))
-      def ++[T >: V](other: TraversableOnce[T]) = OSet.from(items ++ other)
+      def zip[T](other: Agg[T]) = Agg.from(items.zip(other.items))
+      def ++[T >: V](other: TraversableOnce[T]) = Agg.from(items ++ other)
 
       // Members declared in scala.collection.GenTraversableOnce
       def isTraversableAgain: Boolean = items.isTraversableAgain
@@ -107,10 +107,10 @@ sealed class OSetWrapper(strictUniqueness: Boolean){
 
       override def hashCode() = items.map(_.hashCode()).sum
       override def equals(other: Any) = other match{
-        case s: OSet[_] => items.sameElements(s.items)
+        case s: Agg[_] => items.sameElements(s.items)
         case _ => super.equals(other)
       }
-      override def toString = items.mkString("OSet(", ", ", ")")
+      override def toString = items.mkString("Agg(", ", ", ")")
     }
   }
 }