Merge pull request #3424 from travisbrown/topic/simulacrum-scalafix-0…

….2.0 Use Simulacrum Scalafix
typelevel · May 24, 2020 · e7509a1 · e7509a1
2 parents e5fed5a + e657272
commit e7509a1
Show file tree

Hide file tree

Showing 52 changed files with 2,458 additions and 33 deletions.
diff --git a/alleycats-core/src/main/scala/alleycats/ConsK.scala b/alleycats-core/src/main/scala/alleycats/ConsK.scala
@@ -2,8 +2,10 @@ package alleycats
 
 import cats.SemigroupK
 import simulacrum.typeclass
+import scala.annotation.implicitNotFound
 
-@typeclass trait ConsK[F[_]] {
+@implicitNotFound("Could not find an instance of ConsK for ${F}")
+@typeclass trait ConsK[F[_]] extends Serializable {
   def cons[A](hd: A, tl: F[A]): F[A]
 }
 
@@ -12,4 +14,43 @@ object ConsK {
     new ConsK[F] {
       def cons[A](hd: A, tl: F[A]): F[A] = s.combineK(p.pure(hd), tl)
     }
+
+  /****************************************************************************/
+  /* THE FOLLOWING CODE IS MANAGED BY SIMULACRUM; PLEASE DO NOT EDIT!!!!      */
+  /****************************************************************************/
+  /**
+   * Summon an instance of [[ConsK]] for `F`.
+   */
+  @inline def apply[F[_]](implicit instance: ConsK[F]): ConsK[F] = instance
+
+  trait Ops[F[_], A] {
+    type TypeClassType <: ConsK[F]
+    def self: F[A]
+    val typeClassInstance: TypeClassType
+  }
+  trait AllOps[F[_], A] extends Ops[F, A]
+  trait ToConsKOps {
+    implicit def toConsKOps[F[_], A](target: F[A])(implicit tc: ConsK[F]): Ops[F, A] {
+      type TypeClassType = ConsK[F]
+    } = new Ops[F, A] {
+      type TypeClassType = ConsK[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+  object nonInheritedOps extends ToConsKOps
+  object ops {
+    implicit def toAllConsKOps[F[_], A](target: F[A])(implicit tc: ConsK[F]): AllOps[F, A] {
+      type TypeClassType = ConsK[F]
+    } = new AllOps[F, A] {
+      type TypeClassType = ConsK[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+
+  /****************************************************************************/
+  /* END OF SIMULACRUM-MANAGED CODE                                           */
+  /****************************************************************************/
+
 }
diff --git a/alleycats-core/src/main/scala/alleycats/Empty.scala b/alleycats-core/src/main/scala/alleycats/Empty.scala
@@ -4,8 +4,10 @@ import cats.{Eq, Monoid}
 import cats.syntax.eq._
 
 import simulacrum.typeclass
+import scala.annotation.implicitNotFound
 
-@typeclass trait Empty[A] {
+@implicitNotFound("Could not find an instance of Empty for ${A}")
+@typeclass trait Empty[A] extends Serializable {
   def empty: A
 
   def isEmpty(a: A)(implicit ev: Eq[A]): Boolean =
@@ -20,6 +22,47 @@ object Empty extends EmptyInstances0 {
     new Empty[A] { lazy val empty: A = a }
 
   def fromEmptyK[F[_], T](implicit ekf: EmptyK[F]): Empty[F[T]] = ekf.synthesize[T]
+
+  /****************************************************************************/
+  /* THE FOLLOWING CODE IS MANAGED BY SIMULACRUM; PLEASE DO NOT EDIT!!!!      */
+  /****************************************************************************/
+  /**
+   * Summon an instance of [[Empty]] for `A`.
+   */
+  @inline def apply[A](implicit instance: Empty[A]): Empty[A] = instance
+
+  trait Ops[A] {
+    type TypeClassType <: Empty[A]
+    def self: A
+    val typeClassInstance: TypeClassType
+    def isEmpty(implicit ev: Eq[A]): Boolean = typeClassInstance.isEmpty(self)(ev)
+    def nonEmpty(implicit ev: Eq[A]): Boolean = typeClassInstance.nonEmpty(self)(ev)
+  }
+  trait AllOps[A] extends Ops[A]
+  trait ToEmptyOps {
+    implicit def toEmptyOps[A](target: A)(implicit tc: Empty[A]): Ops[A] {
+      type TypeClassType = Empty[A]
+    } = new Ops[A] {
+      type TypeClassType = Empty[A]
+      val self: A = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+  object nonInheritedOps extends ToEmptyOps
+  object ops {
+    implicit def toAllEmptyOps[A](target: A)(implicit tc: Empty[A]): AllOps[A] {
+      type TypeClassType = Empty[A]
+    } = new AllOps[A] {
+      type TypeClassType = Empty[A]
+      val self: A = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+
+  /****************************************************************************/
+  /* END OF SIMULACRUM-MANAGED CODE                                           */
+  /****************************************************************************/
+
 }
 
 private[alleycats] trait EmptyInstances0 extends compat.IterableEmptyInstance with EmptyInstances1

diff --git a/alleycats-core/src/main/scala/alleycats/EmptyK.scala b/alleycats-core/src/main/scala/alleycats/EmptyK.scala
@@ -1,12 +1,56 @@
 package alleycats
 
 import simulacrum.typeclass
+import scala.annotation.implicitNotFound
 
-@typeclass trait EmptyK[F[_]] { self =>
+@implicitNotFound("Could not find an instance of EmptyK for ${F}")
+@typeclass trait EmptyK[F[_]] extends Serializable { self =>
   def empty[A]: F[A]
 
   def synthesize[A]: Empty[F[A]] =
     new Empty[F[A]] {
       def empty: F[A] = self.empty[A]
     }
 }
+
+object EmptyK {
+
+  /****************************************************************************/
+  /* THE FOLLOWING CODE IS MANAGED BY SIMULACRUM; PLEASE DO NOT EDIT!!!!      */
+  /****************************************************************************/
+  /**
+   * Summon an instance of [[EmptyK]] for `F`.
+   */
+  @inline def apply[F[_]](implicit instance: EmptyK[F]): EmptyK[F] = instance
+
+  trait Ops[F[_], A] {
+    type TypeClassType <: EmptyK[F]
+    def self: F[A]
+    val typeClassInstance: TypeClassType
+  }
+  trait AllOps[F[_], A] extends Ops[F, A]
+  trait ToEmptyKOps {
+    implicit def toEmptyKOps[F[_], A](target: F[A])(implicit tc: EmptyK[F]): Ops[F, A] {
+      type TypeClassType = EmptyK[F]
+    } = new Ops[F, A] {
+      type TypeClassType = EmptyK[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+  object nonInheritedOps extends ToEmptyKOps
+  object ops {
+    implicit def toAllEmptyKOps[F[_], A](target: F[A])(implicit tc: EmptyK[F]): AllOps[F, A] {
+      type TypeClassType = EmptyK[F]
+    } = new AllOps[F, A] {
+      type TypeClassType = EmptyK[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+
+  /****************************************************************************/
+  /* END OF SIMULACRUM-MANAGED CODE                                           */
+  /****************************************************************************/
+
+}
diff --git a/alleycats-core/src/main/scala/alleycats/Extract.scala b/alleycats-core/src/main/scala/alleycats/Extract.scala
@@ -3,8 +3,10 @@ package alleycats
 import cats.{CoflatMap, Comonad}
 
 import simulacrum.typeclass
+import scala.annotation.implicitNotFound
 
-@typeclass trait Extract[F[_]] {
+@implicitNotFound("Could not find an instance of Extract for ${F}")
+@typeclass trait Extract[F[_]] extends Serializable {
   def extract[A](fa: F[A]): A
 }
 
@@ -22,4 +24,44 @@ object Extract {
       override def map[A, B](fa: F[A])(f: A => B): F[B] = cf.map(fa)(f)
       def coflatMap[A, B](fa: F[A])(f: F[A] => B): F[B] = cf.coflatMap(fa)(f)
     }
+
+  /****************************************************************************/
+  /* THE FOLLOWING CODE IS MANAGED BY SIMULACRUM; PLEASE DO NOT EDIT!!!!      */
+  /****************************************************************************/
+  /**
+   * Summon an instance of [[Extract]] for `F`.
+   */
+  @inline def apply[F[_]](implicit instance: Extract[F]): Extract[F] = instance
+
+  trait Ops[F[_], A] {
+    type TypeClassType <: Extract[F]
+    def self: F[A]
+    val typeClassInstance: TypeClassType
+    def extract: A = typeClassInstance.extract[A](self)
+  }
+  trait AllOps[F[_], A] extends Ops[F, A]
+  trait ToExtractOps {
+    implicit def toExtractOps[F[_], A](target: F[A])(implicit tc: Extract[F]): Ops[F, A] {
+      type TypeClassType = Extract[F]
+    } = new Ops[F, A] {
+      type TypeClassType = Extract[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+  object nonInheritedOps extends ToExtractOps
+  object ops {
+    implicit def toAllExtractOps[F[_], A](target: F[A])(implicit tc: Extract[F]): AllOps[F, A] {
+      type TypeClassType = Extract[F]
+    } = new AllOps[F, A] {
+      type TypeClassType = Extract[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+
+  /****************************************************************************/
+  /* END OF SIMULACRUM-MANAGED CODE                                           */
+  /****************************************************************************/
+
 }
diff --git a/alleycats-core/src/main/scala/alleycats/One.scala b/alleycats-core/src/main/scala/alleycats/One.scala
@@ -3,8 +3,10 @@ package alleycats
 import cats.Eq
 import cats.syntax.eq._
 import simulacrum.typeclass
+import scala.annotation.implicitNotFound
 
-@typeclass trait One[A] {
+@implicitNotFound("Could not find an instance of One for ${A}")
+@typeclass trait One[A] extends Serializable {
   def one: A
 
   def isOne(a: A)(implicit ev: Eq[A]): Boolean =
@@ -17,4 +19,45 @@ import simulacrum.typeclass
 object One {
   def apply[A](a: => A): One[A] =
     new One[A] { lazy val one: A = a }
+
+  /****************************************************************************/
+  /* THE FOLLOWING CODE IS MANAGED BY SIMULACRUM; PLEASE DO NOT EDIT!!!!      */
+  /****************************************************************************/
+  /**
+   * Summon an instance of [[One]] for `A`.
+   */
+  @inline def apply[A](implicit instance: One[A]): One[A] = instance
+
+  trait Ops[A] {
+    type TypeClassType <: One[A]
+    def self: A
+    val typeClassInstance: TypeClassType
+    def isOne(implicit ev: Eq[A]): Boolean = typeClassInstance.isOne(self)(ev)
+    def nonOne(implicit ev: Eq[A]): Boolean = typeClassInstance.nonOne(self)(ev)
+  }
+  trait AllOps[A] extends Ops[A]
+  trait ToOneOps {
+    implicit def toOneOps[A](target: A)(implicit tc: One[A]): Ops[A] {
+      type TypeClassType = One[A]
+    } = new Ops[A] {
+      type TypeClassType = One[A]
+      val self: A = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+  object nonInheritedOps extends ToOneOps
+  object ops {
+    implicit def toAllOneOps[A](target: A)(implicit tc: One[A]): AllOps[A] {
+      type TypeClassType = One[A]
+    } = new AllOps[A] {
+      type TypeClassType = One[A]
+      val self: A = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+
+  /****************************************************************************/
+  /* END OF SIMULACRUM-MANAGED CODE                                           */
+  /****************************************************************************/
+
 }
diff --git a/alleycats-core/src/main/scala/alleycats/Pure.scala b/alleycats-core/src/main/scala/alleycats/Pure.scala
@@ -2,8 +2,10 @@ package alleycats
 
 import cats.{Applicative, FlatMap, Monad}
 import simulacrum.typeclass
+import scala.annotation.implicitNotFound
 
-@typeclass trait Pure[F[_]] {
+@implicitNotFound("Could not find an instance of Pure for ${F}")
+@typeclass trait Pure[F[_]] extends Serializable {
   def pure[A](a: A): F[A]
 }
 
@@ -22,4 +24,43 @@ object Pure {
       def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B] = fm.flatMap(fa)(f)
       def tailRecM[A, B](a: A)(f: (A) => F[Either[A, B]]): F[B] = fm.tailRecM(a)(f)
     }
+
+  /****************************************************************************/
+  /* THE FOLLOWING CODE IS MANAGED BY SIMULACRUM; PLEASE DO NOT EDIT!!!!      */
+  /****************************************************************************/
+  /**
+   * Summon an instance of [[Pure]] for `F`.
+   */
+  @inline def apply[F[_]](implicit instance: Pure[F]): Pure[F] = instance
+
+  trait Ops[F[_], A] {
+    type TypeClassType <: Pure[F]
+    def self: F[A]
+    val typeClassInstance: TypeClassType
+  }
+  trait AllOps[F[_], A] extends Ops[F, A]
+  trait ToPureOps {
+    implicit def toPureOps[F[_], A](target: F[A])(implicit tc: Pure[F]): Ops[F, A] {
+      type TypeClassType = Pure[F]
+    } = new Ops[F, A] {
+      type TypeClassType = Pure[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+  object nonInheritedOps extends ToPureOps
+  object ops {
+    implicit def toAllPureOps[F[_], A](target: F[A])(implicit tc: Pure[F]): AllOps[F, A] {
+      type TypeClassType = Pure[F]
+    } = new AllOps[F, A] {
+      type TypeClassType = Pure[F]
+      val self: F[A] = target
+      val typeClassInstance: TypeClassType = tc
+    }
+  }
+
+  /****************************************************************************/
+  /* END OF SIMULACRUM-MANAGED CODE                                           */
+  /****************************************************************************/
+
 }