Begin bundling sequential ops macros

collections/src/main/scala/basis/collections/BilinearSeq.scala

@@ -30,8 +30,8 @@ object BilinearSeq extends generic.SeqFactory[BilinearSeq] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[BilinearSeq[A]] =
-    immutable.Batch.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[BilinearSeq[A]] =
+    immutable.Batch.Builder[A]
 
   override def toString: String = "BilinearSeq"
 }

collections/src/main/scala/basis/collections/Buffer.scala

@@ -69,8 +69,8 @@ object Buffer extends generic.SeqFactory[Buffer] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Buffer[A]] =
-    mutable.ListBuffer.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Buffer[A]] =
+    mutable.ListBuffer.Builder[A]
 
   private[collections] final class Append[-A](b: Builder[A]) extends scala.runtime.AbstractFunction1[A, Unit] {
     override def apply(elem: A): Unit = b.append(elem)

collections/src/main/scala/basis/collections/Collection.scala

@@ -33,8 +33,8 @@ object Collection extends generic.CollectionFactory[Collection] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Collection[A]] =
-    immutable.List.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Collection[A]] =
+    immutable.List.Builder[A]
 
   override def toString: String = "Collection"
 

collections/src/main/scala/basis/collections/Container.scala

@@ -40,8 +40,8 @@ object Container extends generic.CollectionFactory[Container] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Container[A]] =
-    immutable.List.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Container[A]] =
+    immutable.List.Builder[A]
 
   override def toString: String = "Container"
 }

collections/src/main/scala/basis/collections/Deque.scala

@@ -24,8 +24,8 @@ object Deque extends generic.SeqFactory[Deque] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Deque[A]] =
-    immutable.Batch.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Deque[A]] =
+    immutable.Batch.Builder[A]
 
   override def toString: String = "Deque"
 }

collections/src/main/scala/basis/collections/IndexedSeq.scala

@@ -72,8 +72,8 @@ object IndexedSeq extends generic.SeqFactory[IndexedSeq] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[IndexedSeq[A]] =
-    immutable.Vector.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[IndexedSeq[A]] =
+    immutable.Vector.Builder[A]
 
   override def toString: String = "IndexedSeq"
 }

collections/src/main/scala/basis/collections/LinearSeq.scala

@@ -73,8 +73,8 @@ object LinearSeq extends generic.SeqFactory[LinearSeq] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[LinearSeq[A]] =
-    immutable.List.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[LinearSeq[A]] =
+    immutable.List.Builder[A]
 
   override def toString: String = "LinearSeq"
 }

collections/src/main/scala/basis/collections/Map.scala

@@ -117,7 +117,7 @@ object Map extends generic.MapFactory[Map] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A, T](): Builder[(A, T)] with State[Map[A, T]] =
+  implicit override def Builder[A, T]: Builder[(A, T)] with State[Map[A, T]] =
     immutable.HashMap.Builder[A, T]
 
   override def toString: String = "Map"

collections/src/main/scala/basis/collections/Queue.scala

@@ -20,8 +20,8 @@ object Queue extends generic.SeqFactory[Queue] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Queue[A]] =
-    immutable.Batch.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Queue[A]] =
+    immutable.Batch.Builder[A]
 
   override def toString: String = "Queue"
 }

collections/src/main/scala/basis/collections/Seq.scala

@@ -56,8 +56,8 @@ object Seq extends generic.SeqFactory[Seq] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Seq[A]] =
-    immutable.List.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Seq[A]] =
+    immutable.List.Builder[A]
 
   override def toString: String = "Seq"
 }

collections/src/main/scala/basis/collections/Set.scala

@@ -69,8 +69,8 @@ object Set extends generic.SetFactory[Set] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Set[A]] =
-    immutable.HashSet.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Set[A]] =
+    immutable.HashSet.Builder[A]
 
   override def toString: String = "Set"
 }

collections/src/main/scala/basis/collections/Stack.scala

@@ -20,8 +20,8 @@ object Stack extends generic.SeqFactory[Stack] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Stack[A]] =
-    immutable.List.Builder[A]()
+  implicit override def Builder[A]: Builder[A] with State[Stack[A]] =
+    immutable.List.Builder[A]
 
   override def toString: String = "Stack"
 }

collections/src/main/scala/basis/collections/generic/ArrayFactory.scala

@@ -11,31 +11,31 @@ import scala.reflect._
 import basis.util._
 
 trait ArrayFactory[+CC[_]] {
-  def empty[A](implicit A: ClassTag[A]): CC[A]           = Builder[A]().state
+  def empty[A](implicit A: ClassTag[A]): CC[A]           = Builder[A].state
   def apply[A](elems: A*): CC[A]                         = macro ArrayFactory.apply[CC, A]
   def fill[A](count: Int)(elem: => A): CC[A]             = macro ArrayFactory.fill[CC, A]
   def tabulate[A](count: Int)(f: Int => A): CC[A]        = macro ArrayFactory.tabulate[CC, A]
   def iterate[A](start: A, count: Int)(f: A => A): CC[A] = macro ArrayFactory.iterate[CC, A]
 
   def coerce[A](elems: Traverser[A]): CC[A] = {
-    val builder = Builder[A]()(ClassTag.AnyRef.asInstanceOf[ClassTag[A]])
+    val builder = Builder[A](ClassTag.AnyRef.asInstanceOf[ClassTag[A]])
     elems.traverse(new Buffer.Append(builder))
     builder.state
   }
 
   def from[A](elems: Traverser[A])(implicit A: ClassTag[A]): CC[A] = {
-    val builder = Builder[A]()
+    val builder = Builder[A]
     elems.traverse(new Buffer.Append(builder))
     builder.state
   }
 
   def from[A](elems: scala.collection.TraversableOnce[A])(implicit A: ClassTag[A]): CC[A] = {
-    val builder = Builder[A]()
+    val builder = Builder[A]
     elems.foreach(new Buffer.Append(builder))
     builder.state
   }
 
-  implicit def Builder[A]()(implicit A: ClassTag[A]): Builder[A] with State[CC[A]]
+  implicit def Builder[A](implicit A: ClassTag[A]): Builder[A] with State[CC[A]]
 }
 
 private[generic] object ArrayFactory extends FactoryMacros[ArrayFactory] {
@@ -50,7 +50,7 @@ private[generic] object ArrayFactory extends FactoryMacros[ArrayFactory] {
     import c.{ Expr, prefix, weakTypeOf, WeakTypeTag }
     import c.universe._
 
-    var b = Apply(TypeApply(Select(prefix.tree, "Builder": TermName), TypeTree(weakTypeOf[A]) :: Nil), Nil)
+    var b: Tree = TypeApply(Select(prefix.tree, "Builder": TermName), TypeTree(weakTypeOf[A]) :: Nil)
     b = Apply(Select(b, "expect": TermName), Literal(Constant(elems.length)) :: Nil)
 
     val xs = elems.iterator

collections/src/main/scala/basis/collections/generic/CollectionFactory.scala

@@ -11,24 +11,24 @@ import basis.util._
 // applied
 
 trait CollectionFactory[+CC[_]] {
-  def empty[A]: CC[A] = Builder[A]().state
+  def empty[A]: CC[A] = Builder[A].state
 
   def apply[A](elems: A*): CC[A] =
     macro CollectionFactory.apply[CC, A]
 
   def from[A](elems: Traverser[A]): CC[A] = {
-    val builder = Builder[A]()
+    val builder = Builder[A]
     elems.traverse(new Buffer.Append(builder))
     builder.state
   }
 
   def from[A](elems: scala.collection.TraversableOnce[A]): CC[A] = {
-    val builder = Builder[A]()
+    val builder = Builder[A]
     elems.foreach(new Buffer.Append(builder))
     builder.state
   }
 
-  implicit def Builder[A](): Builder[A] with State[CC[A]]
+  implicit def Builder[A]: Builder[A] with State[CC[A]]
 
   implicit def Factory: CollectionFactory[CC] = this
 }
@@ -45,7 +45,7 @@ private[generic] object CollectionFactory {
     import c.{ Expr, prefix, weakTypeOf, WeakTypeTag }
     import c.universe._
 
-    var b = Apply(TypeApply(Select(prefix.tree, "Builder": TermName), TypeTree(weakTypeOf[A]) :: Nil), Nil)
+    var b: Tree = TypeApply(Select(prefix.tree, "Builder": TermName), TypeTree(weakTypeOf[A]) :: Nil)
     b = Apply(Select(b, "expect": TermName), Literal(Constant(elems.length)) :: Nil)
 
     val xs = elems.iterator

collections/src/main/scala/basis/collections/generic/MapFactory.scala

@@ -10,24 +10,24 @@ package generic
 import basis.util._
 
 trait MapFactory[+CC[_, _]] {
-  def empty[A, T]: CC[A, T] = Builder[A, T]().state
+  def empty[A, T]: CC[A, T] = Builder[A, T].state
 
   def apply[A, T](entries: (A, T)*): CC[A, T] =
     macro MapFactory.apply[CC, A, T]
 
   def from[A, T](entries: Traverser[(A, T)]): CC[A, T] = {
-    val builder = Builder[A, T]()
+    val builder = Builder[A, T]
     entries traverse new Buffer.Append(builder)
     builder.state
   }
 
   def from[A, T](entries: TraversableOnce[(A, T)]): CC[A, T] = {
-    val builder = Builder[A, T]()
+    val builder = Builder[A, T]
     entries foreach new Buffer.Append(builder)
     builder.state
   }
 
-  implicit def Builder[A, T](): Builder[(A, T)] with State[CC[A, T]]
+  implicit def Builder[A, T]: Builder[(A, T)] with State[CC[A, T]]
 
   implicit def Factory: MapFactory[CC] = this
 }
@@ -44,7 +44,7 @@ private[generic] object MapFactory {
     import c.{ Expr, prefix, weakTypeOf, WeakTypeTag }
     import c.universe._
 
-    var b = Apply(TypeApply(Select(prefix.tree, "Builder": TermName), TypeTree(weakTypeOf[A]) :: TypeTree(weakTypeOf[T]) :: Nil), Nil)
+    var b: Tree = TypeApply(Select(prefix.tree, "Builder": TermName), TypeTree(weakTypeOf[A]) :: TypeTree(weakTypeOf[T]) :: Nil)
     b = Apply(Select(b, "expect": TermName), Literal(Constant(entries.length)) :: Nil)
 
     val xs = entries.iterator

collections/src/main/scala/basis/collections/immutable/ArrayMap.scala

@@ -156,7 +156,7 @@ private[collections] object ArrayMap extends MapFactory[ArrayMap] {
     new ArrayMap(slots)
   }
 
-  implicit override def Builder[A, T](): Builder[(A, T)] with State[ArrayMap[A, T]] =
+  implicit override def Builder[A, T]: Builder[(A, T)] with State[ArrayMap[A, T]] =
     new ArrayMapBuilder[A, T]
 
   override def toString: String = "ArrayMap"

collections/src/main/scala/basis/collections/immutable/ArraySeq.scala

@@ -155,7 +155,7 @@ abstract class ArraySeq[+A]
 }
 
 object ArraySeq extends ArrayFactory[ArraySeq] {
-  implicit override def Builder[A]()(implicit A: ClassTag[A])
+  implicit override def Builder[A](implicit A: ClassTag[A])
     : ArrayBuilder[A] with State[ArraySeq[A]] = (A match {
     case ClassTag.Byte    => new ByteArraySeqBuilder
     case ClassTag.Short   => new ShortArraySeqBuilder

collections/src/main/scala/basis/collections/immutable/ArraySet.scala

@@ -104,7 +104,7 @@ private[collections] object ArraySet extends SetFactory[ArraySet] {
     }
   }
 
-  implicit override def Builder[A](): Builder[A] with State[ArraySet[A]] =
+  implicit override def Builder[A]: Builder[A] with State[ArraySet[A]] =
     new ArraySetBuilder[A]
 
   override def toString: String = "ArraySet"

collections/src/main/scala/basis/collections/immutable/Batch.scala

@@ -63,7 +63,7 @@ object Batch extends generic.SeqFactory[Batch] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Batch[A]] =
+  implicit override def Builder[A]: Builder[A] with State[Batch[A]] =
     new BatchBuilder[A]
 
   override def toString: String = "Batch"

collections/src/main/scala/basis/collections/immutable/HashMap.scala

@@ -375,7 +375,7 @@ object HashMap extends MapFactory[HashMap] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A, T](): Builder[(A, T)] with State[HashMap[A, T]] =
+  implicit override def Builder[A, T]: Builder[(A, T)] with State[HashMap[A, T]] =
     new HashMapBuilder[A, T]
 
   override def toString: String = "HashMap"

collections/src/main/scala/basis/collections/immutable/HashSet.scala

@@ -230,7 +230,7 @@ object HashSet extends SetFactory[HashSet] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[HashSet[A]] =
+  implicit override def Builder[A]: Builder[A] with State[HashSet[A]] =
     new HashSetBuilder[A]
 
   override def toString: String = "HashSet"

collections/src/main/scala/basis/collections/immutable/List.scala

@@ -73,7 +73,7 @@ object List extends SeqFactory[List] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[List[A]] =
+  implicit override def Builder[A]: Builder[A] with State[List[A]] =
     new ListBuilder[A]
 
   override def toString: String = "List"

collections/src/main/scala/basis/collections/immutable/Vector.scala

@@ -517,7 +517,7 @@ object Vector extends SeqFactory[Vector] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[Vector[A]] =
+  implicit override def Builder[A]: Builder[A] with State[Vector[A]] =
     new VectorBuilder[A]
 
   private[collections] def traverse1[A](node1: Array[AnyRef])(f: A => Unit): Unit = {

collections/src/main/scala/basis/collections/mutable/ArrayBuffer.scala

@@ -72,7 +72,7 @@ abstract class ArrayBuffer[A]
 }
 
 object ArrayBuffer extends ArrayFactory[ArrayBuffer] {
-  implicit override def Builder[A]()(implicit A: ClassTag[A])
+  implicit override def Builder[A](implicit A: ClassTag[A])
     : ArrayBuilder[A] with State[ArrayBuffer[A]] = (A match {
     case ClassTag.Byte   => new ByteArrayBufferBuilder
     case ClassTag.Short  => new ShortArrayBufferBuilder

collections/src/main/scala/basis/collections/mutable/ListBuffer.scala

@@ -274,7 +274,7 @@ object ListBuffer extends SeqFactory[ListBuffer] {
     else super.from(elems)
   }
 
-  implicit override def Builder[A](): Builder[A] with State[ListBuffer[A]] =
+  implicit override def Builder[A]: Builder[A] with State[ListBuffer[A]] =
     new ListBufferBuilder[A]
 
   override def toString: String = "ListBuffer"