typelevel · kailuowang · Apr 16, 2019 · Apr 16, 2019
diff --git a/alleycats-core/src/main/scala/alleycats/ConsK.scala b/alleycats-core/src/main/scala/alleycats/ConsK.scala
@@ -1,19 +1,15 @@
 package alleycats
 
 import cats.SemigroupK
-import export.imports
 import simulacrum.typeclass
 
 @typeclass trait ConsK[F[_]] {
   def cons[A](hd: A, tl: F[A]): F[A]
 }
 
-object ConsK extends ConsK0 {
+object ConsK {
   implicit def pureSemigroupKIsConsK[F[_]](implicit p: Pure[F], s: SemigroupK[F]): ConsK[F] =
     new ConsK[F] {
       def cons[A](hd: A, tl: F[A]): F[A] = s.combineK(p.pure(hd), tl)
     }
 }
-
-@imports[ConsK]
-trait ConsK0
diff --git a/alleycats-core/src/main/scala/alleycats/Empty.scala b/alleycats-core/src/main/scala/alleycats/Empty.scala
@@ -2,9 +2,8 @@ package alleycats
 
 import cats.{Eq, Monoid}
 import cats.syntax.eq._
-import export.imports
+
 import simulacrum.typeclass
-import scala.collection.generic.CanBuildFrom
 
 @typeclass trait Empty[A] {
   def empty: A
@@ -19,15 +18,14 @@ import scala.collection.generic.CanBuildFrom
 object Empty extends EmptyInstances0 {
   def apply[A](a: => A): Empty[A] =
     new Empty[A] { lazy val empty: A = a }
+
+  def fromEmptyK[F[_], T](implicit ekf: EmptyK[F]): Empty[F[T]] = ekf.synthesize[T]
 }
 
 trait EmptyInstances0 extends compat.IterableEmptyInstance with EmptyInstances1
 
-trait EmptyInstances1 extends EmptyInstances2 {
+trait EmptyInstances1 {
   // If Monoid extended Empty then this could be an exported subclass instance provided by Monoid
   implicit def monoidIsEmpty[A: Monoid]: Empty[A] =
     Empty(Monoid[A].empty)
 }
-
-@imports[Empty]
-trait EmptyInstances2
diff --git a/alleycats-core/src/main/scala/alleycats/EmptyK.scala b/alleycats-core/src/main/scala/alleycats/EmptyK.scala
@@ -1,6 +1,5 @@
 package alleycats
 
-import export._
 import simulacrum.typeclass
 
 @typeclass trait EmptyK[F[_]] { self =>
@@ -11,12 +10,3 @@ import simulacrum.typeclass
       def empty: F[A] = self.empty[A]
     }
 }
-
-@imports[EmptyK]
-object EmptyK
-
-@exports
-object EmptyKInstances {
-  @export(Instantiated)
-  implicit def instantiate[F[_], T](implicit ekf: EmptyK[F]): Empty[F[T]] = ekf.synthesize[T]
-}
diff --git a/alleycats-core/src/main/scala/alleycats/Extract.scala b/alleycats-core/src/main/scala/alleycats/Extract.scala
@@ -1,14 +1,14 @@
 package alleycats
 
 import cats.{CoflatMap, Comonad}
-import export.imports
+
 import simulacrum.typeclass
 
 @typeclass trait Extract[F[_]] {
   def extract[A](fa: F[A]): A
 }
 
-object Extract extends Extract0 {
+object Extract {
   // Ideally this would be an exported subclass instance provided by Comonad
   implicit def comonadIsExtract[F[_]](implicit ev: Comonad[F]): Extract[F] =
     new Extract[F] {
@@ -23,6 +23,3 @@ object Extract extends Extract0 {
       def coflatMap[A, B](fa: F[A])(f: F[A] => B): F[B] = cf.coflatMap(fa)(f)
     }
 }
-
-@imports[Extract]
-trait Extract0
diff --git a/alleycats-core/src/main/scala/alleycats/One.scala b/alleycats-core/src/main/scala/alleycats/One.scala
@@ -1,8 +1,7 @@
 package alleycats
 
-import cats.{Eq, Monoid}
+import cats.Eq
 import cats.syntax.eq._
-import export.imports
 import simulacrum.typeclass
 
 @typeclass trait One[A] {
@@ -15,10 +14,7 @@ import simulacrum.typeclass
     one =!= a
 }
 
-object One extends One0 {
+object One {
   def apply[A](a: => A): One[A] =
     new One[A] { lazy val one: A = a }
 }
-
-@imports[One]
-trait One0
diff --git a/alleycats-core/src/main/scala/alleycats/Pure.scala b/alleycats-core/src/main/scala/alleycats/Pure.scala
@@ -1,14 +1,13 @@
 package alleycats
 
 import cats.{Applicative, FlatMap, Monad}
-import export.imports
 import simulacrum.typeclass
 
 @typeclass trait Pure[F[_]] {
   def pure[A](a: A): F[A]
 }
 
-object Pure extends Pure0 {
+object Pure {
   // Ideally this would be an exported subclass instance provided by Applicative
   implicit def applicativeIsPure[F[_]](implicit ev: Applicative[F]): Pure[F] =
     new Pure[F] {
@@ -24,6 +23,3 @@ object Pure extends Pure0 {
       def tailRecM[A, B](a: A)(f: (A) => F[Either[A, B]]): F[B] = fm.tailRecM(a)(f)
     }
 }
-
-@imports[Pure]
-trait Pure0
diff --git a/alleycats-core/src/main/scala/alleycats/Zero.scala b/alleycats-core/src/main/scala/alleycats/Zero.scala
@@ -2,7 +2,7 @@ package alleycats
 
 import cats.Eq
 import cats.syntax.eq._
-import export.imports
+
 import simulacrum.typeclass
 
 @typeclass trait Zero[A] {
@@ -15,10 +15,7 @@ import simulacrum.typeclass
     zero =!= a
 }
 
-object Zero extends Zero0 {
+object Zero {
   def apply[A](a: => A): Zero[A] =
     new Zero[A] { lazy val zero: A = a }
 }
-
-@imports[Zero]
-trait Zero0
diff --git a/alleycats-core/src/main/scala/alleycats/std/all.scala b/alleycats-core/src/main/scala/alleycats/std/all.scala
@@ -1,18 +1,11 @@
 package alleycats
 package std
 
-import export._
-
-@reexports(EmptyKInstances,
-           ListInstances,
-           OptionInstances,
-           SetInstances,
-           TryInstances,
-           IterableInstances,
-           FutureInstances) object all
-    extends LegacySetInstances
-    with LegacySetInstancesBinCompat0
-    with LegacyTryInstances
-    with LegacyIterableInstances
+object all
+    extends SetInstances
+    with FutureInstances
+    with ListInstances
     with MapInstances
-    with MapInstancesBinCompat0
+    with OptionInstances
+    with TryInstances
+    with IterableInstances
diff --git a/alleycats-core/src/main/scala/alleycats/std/future.scala b/alleycats-core/src/main/scala/alleycats/std/future.scala
@@ -1,16 +1,13 @@
 package alleycats
 package std
 
-import export._
-
 import scala.concurrent.Future
 
-@reexports(FutureInstances)
-object future
+object future extends FutureInstances
+
+trait FutureInstances {
 
-object FutureInstances {
-  @export(Orphan)
-  implicit val exportFuturePure: Pure[Future] =
+  implicit val alleycatsStdFuturePure: Pure[Future] =
     new Pure[Future] {
       override def pure[A](a: A): Future[A] = Future.successful(a)
     }

diff --git a/alleycats-core/src/main/scala/alleycats/std/iterable.scala b/alleycats-core/src/main/scala/alleycats/std/iterable.scala
@@ -2,15 +2,11 @@ package alleycats
 package std
 
 import cats.{Eval, Foldable, Monoid}
-import export._
 
-@reexports(IterableInstances)
-object iterable extends LegacyIterableInstances
+object iterable extends IterableInstances
 
-@exports
-object IterableInstances {
-  @export(Orphan)
-  implicit val exportIterableFoldable: Foldable[Iterable] =
+trait IterableInstances {
+  implicit val alleycatsStdIterableFoldable: Foldable[Iterable] =
     new Foldable[Iterable] {
       override def foldLeft[A, B](fa: Iterable[A], b: B)(f: (B, A) => B): B = fa.foldLeft(b)(f)
 
@@ -20,10 +16,4 @@ object IterableInstances {
       override def foldMap[A, B](fa: Iterable[A])(f: A => B)(implicit B: Monoid[B]): B =
         B.combineAll(fa.iterator.map(f))
     }
-
-}
-
-// TODO: remove when cats.Foldable support export-hook
-trait LegacyIterableInstances {
-  implicit def legacyIterableFoldable(implicit e: ExportOrphan[Foldable[Iterable]]): Foldable[Iterable] = e.instance
 }
diff --git a/alleycats-core/src/main/scala/alleycats/std/list.scala b/alleycats-core/src/main/scala/alleycats/std/list.scala
@@ -1,21 +1,15 @@
 package alleycats
 package std
 
-import export._
+object list extends ListInstances
 
-@reexports(ListInstances)
-object list
-
-@exports
-object ListInstances {
-  @export(Orphan)
-  implicit val exportListEmptyK: EmptyK[List] =
+trait ListInstances {
+  implicit val alleycatsStdListEmptyK: EmptyK[List] =
     new EmptyK[List] {
       def empty[A]: List[A] = Nil
     }
 
-  @export(Orphan)
-  implicit val exportListConsK: ConsK[List] =
+  implicit val alleycatsStdListConsK: ConsK[List] =
     new ConsK[List] {
       def cons[A](hd: A, tl: List[A]): List[A] = hd :: tl
     }

diff --git a/alleycats-core/src/main/scala/alleycats/std/map.scala b/alleycats-core/src/main/scala/alleycats/std/map.scala
@@ -3,7 +3,7 @@ package std
 
 import cats._
 
-object map extends MapInstances with MapInstancesBinCompat0
+object map extends MapInstances
 
 trait MapInstances {
 
@@ -58,10 +58,8 @@ trait MapInstances {
       override def collectFirstSome[A, B](fa: Map[K, A])(f: A => Option[B]): Option[B] =
         collectFirst(fa)(Function.unlift(f))
     }
-}
 
-trait MapInstancesBinCompat0 extends MapInstances {
-  implicit def mapTraverseFilter[K]: TraverseFilter[Map[K, ?]] =
+  implicit def alleycatsStdMapTraverseFilter[K]: TraverseFilter[Map[K, ?]] =
     new TraverseFilter[Map[K, ?]] {
       def traverse: Traverse[Map[K, ?]] = alleycatsStdInstancesForMap
 

diff --git a/alleycats-core/src/main/scala/alleycats/std/option.scala b/alleycats-core/src/main/scala/alleycats/std/option.scala
@@ -1,15 +1,10 @@
 package alleycats
 package std
 
-import export._
+object option extends OptionInstances
 
-@reexports(OptionInstances)
-object option
-
-@exports
-object OptionInstances {
-  @export(Orphan)
-  implicit val exportOptionEmptyK: EmptyK[Option] =
+trait OptionInstances {
+  implicit val alleycatsStdOptionEmptyK: EmptyK[Option] =
     new EmptyK[Option] {
       def empty[A]: Option[A] = None
     }

diff --git a/alleycats-core/src/main/scala/alleycats/std/set.scala b/alleycats-core/src/main/scala/alleycats/std/set.scala
@@ -1,12 +1,12 @@
 package alleycats.std
 
 import cats.{Applicative, Eval, Foldable, Monad, Monoid, Traverse, TraverseFilter}
-import export._
 
 import scala.annotation.tailrec
 
-@exports
-object SetInstances {
+object set extends SetInstances
+
+trait SetInstances {
   // This method advertises parametricity, but relies on using
   // universal hash codes and equality, which hurts our ability to
   // rely on free theorems.
@@ -27,8 +27,7 @@ object SetInstances {
   // contain three. Since `g` is not a function (speaking strictly)
   // this would not be considered a law violation, but it still makes
   // people uncomfortable.
-  @export(Orphan)
-  implicit val setMonad: Monad[Set] =
+  implicit val alleyCatsStdSetMonad: Monad[Set] =
     new Monad[Set] {
       def pure[A](a: A): Set[A] = Set(a)
       override def map[A, B](fa: Set[A])(f: A => B): Set[B] = fa.map(f)
@@ -60,8 +59,7 @@ object SetInstances {
   // Since iteration order is not guaranteed for sets, folds and other
   // traversals may produce different results for input sets which
   // appear to be the same.
-  @export(Orphan)
-  implicit val setTraverse: Traverse[Set] =
+  implicit val alleyCatsSetTraverse: Traverse[Set] =
     new Traverse[Set] {
       def foldLeft[A, B](fa: Set[A], b: B)(f: (B, A) => B): B =
         fa.foldLeft(b)(f)
@@ -117,10 +115,9 @@ object SetInstances {
         fa.collectFirst(Function.unlift(f))
     }
 
-  @export(Orphan)
-  implicit val setTraverseFilter: TraverseFilter[Set] =
+  implicit val alleyCatsSetTraverseFilter: TraverseFilter[Set] =
     new TraverseFilter[Set] {
-      val traverse: Traverse[Set] = setTraverse
+      val traverse: Traverse[Set] = alleyCatsSetTraverse
 
       def traverseFilter[G[_], A, B](fa: Set[A])(f: A => G[Option[B]])(implicit G: Applicative[G]): G[Set[B]] =
         fa.foldLeft(G.pure(Set.empty[B])) { (gSet, a) =>
@@ -131,17 +128,3 @@ object SetInstances {
         }
     }
 }
-
-@reexports(SetInstances)
-object set extends LegacySetInstances with LegacySetInstancesBinCompat0
-
-// TODO: remove when cats.{ Set, Traverse } support export-hook
-trait LegacySetInstances {
-  implicit def legacySetMonad(implicit e: ExportOrphan[Monad[Set]]): Monad[Set] = e.instance
-
-  implicit def legacySetTraverse(implicit e: ExportOrphan[Traverse[Set]]): Traverse[Set] = e.instance
-}
-
-trait LegacySetInstancesBinCompat0 {
-  implicit def legacySetTraverseFilter(implicit e: ExportOrphan[TraverseFilter[Set]]): TraverseFilter[Set] = e.instance
-}