use private[this]

atnos-org · Jul 25, 2021 · 246f7da · 246f7da
1 parent 8e5aeed
commit 246f7da
Show file tree

Hide file tree

Showing 4 changed files with 12 additions and 12 deletions.
diff --git a/monix/shared/src/main/scala/org/atnos/eff/addon/monix/TaskEffect.scala b/monix/shared/src/main/scala/org/atnos/eff/addon/monix/TaskEffect.scala
@@ -41,7 +41,7 @@ trait TaskCreation extends TaskTypes {
   final def asyncBoundary[R :_task](s: Scheduler): Eff[R, Unit] =
     fromTask(forkedUnit.executeOn(s))
 
-  private val forkedUnit: Task[Unit] =
+  private[this] val forkedUnit: Task[Unit] =
     Task.unit.executeAsync
 
   final def taskAsync[R :_task, A](callbackConsumer: ((Throwable Either A) => Unit) => Unit,
@@ -64,10 +64,10 @@ object TaskCreation extends TaskCreation
 
 trait TaskInterpretation extends TaskTypes {
 
-  private val monixTaskMonad: MonadError[Task, Throwable] =
+  private[this] val monixTaskMonad: MonadError[Task, Throwable] =
     MonadError[Task, Throwable]
 
-  private val monixTaskApplicative = new Applicative[Task] {
+  private[this] val monixTaskApplicative = new Applicative[Task] {
     override def ap[A, B](ff: Task[(A) => B])(fa: Task[A]): Task[B] = Task.mapBoth(ff, fa)(_ (_))
 
     override def map2[A, B, Z](fa: Task[A], fb: Task[B])(f: (A, B) => Z): Task[Z] = Task.mapBoth(fa, fb)(f)
@@ -167,7 +167,7 @@ trait EffToTask[R] {
 trait TaskEffect extends TaskInterpretation with TaskCreation { outer =>
 
   implicit def asyncInstance[R :_Task](implicit runEff: EffToTask[R]): cats.effect.Async[Eff[R, *]] = new cats.effect.Async[Eff[R, *]] {
-    private val taskAsyncInstance: cats.effect.Async[Task] =
+    private[this] val taskAsyncInstance: cats.effect.Async[Task] =
       implicitly[cats.effect.Async[Task]]
 
     override def asyncF[A](k: (Either[Throwable, A] => Unit) => Eff[R, Unit]): Eff[R, A] = fromTask(taskAsyncInstance.asyncF[A] { f => runEff(k(f)) })
@@ -203,10 +203,10 @@ trait TaskEffect extends TaskInterpretation with TaskCreation { outer =>
 
   def effectInstance[R :_Task](implicit runEff: EffToTask[R], scheduler: Scheduler): cats.effect.Effect[Eff[R, *]] = new cats.effect.Effect[Eff[R, *]] {
 
-    private val taskEffectInstance: cats.effect.Effect[Task] =
+    private[this] val taskEffectInstance: cats.effect.Effect[Task] =
       implicitly[cats.effect.Effect[Task]]
 
-    private val asyncInstance: cats.effect.Async[Eff[R, *]] =
+    private[this] val asyncInstance: cats.effect.Async[Eff[R, *]] =
       outer.asyncInstance
 
     override def asyncF[A](k: (Either[Throwable, A] => Unit) => Eff[R, Unit]) = asyncInstance.asyncF(k)

diff --git a/shared/src/main/scala-2/org/atnos/eff/ConcurrentWeakIdentityHashMap.scala b/shared/src/main/scala-2/org/atnos/eff/ConcurrentWeakIdentityHashMap.scala
@@ -26,8 +26,8 @@ import java.util.concurrent.ConcurrentMap
  */
 class ConcurrentWeakIdentityHashMap[K, V] extends ConcurrentMap[K, V] {
 
-  private val map = new ConcurrentHashMap[WeakReference[K], V]
-  private val queue = new ReferenceQueue[K]
+  private[this] val map = new ConcurrentHashMap[WeakReference[K], V]
+  private[this] val queue = new ReferenceQueue[K]
 
   override def putIfAbsent(key: K, value: V): V = {
     purgeKeys()
@@ -155,7 +155,7 @@ class ConcurrentWeakIdentityHashMap[K, V] extends ConcurrentMap[K, V] {
 
   private abstract class WeakSafeIterator[T, U](weakIterator: java.util.Iterator[U]) extends java.util.Iterator[T] {
     advance()
-    private var strongNext: T = null.asInstanceOf[T]
+    private[this] var strongNext: T = null.asInstanceOf[T]
 
     def advance(): Unit  = {
       while (weakIterator.hasNext) {

diff --git a/shared/src/main/scala/org/atnos/eff/EvalEffect.scala b/shared/src/main/scala/org/atnos/eff/EvalEffect.scala
@@ -71,7 +71,7 @@ trait EvalInterpretation extends EvalTypes {
 
   /** the monad error instance for Eval is useful for using detach on Eff[Fx1[Eval], A] */
   implicit final val monadErrorEval: MonadError[Eval, Throwable] = new MonadError[Eval, Throwable] {
-    private val m: Monad[Eval] = Eval.catsBimonadForEval
+    private[this] val m: Monad[Eval] = Eval.catsBimonadForEval
 
     def pure[A](x: A): Eval[A] =
       m.pure(x)

diff --git a/shared/src/main/scala/org/atnos/eff/ValidateEffect.scala b/shared/src/main/scala/org/atnos/eff/ValidateEffect.scala
@@ -92,7 +92,7 @@ trait ValidateInterpretation extends ValidateCreation {
   private def runMapGen[R, U, E, L : Semigroup, A, SomeOr[_, _]](effect: Eff[R, A])(map: E => L)(pure: (A, L Either Option[L]) => L SomeOr A)(implicit m: Member.Aux[Validate[E, *], R, U]): Eff[U, L SomeOr A] =
     runInterpreter(effect)(new Interpreter[Validate[E, *], U, A, L SomeOr A] {
       // Left means failed, Right means not failed (Option contains warnings)
-      private var l: L Either Option[L] = Right(None)
+      private[this] var l: L Either Option[L] = Right(None)
 
       def onPure(a: A): Eff[U, L SomeOr A] =
         Eff.pure(pure(a, l))
@@ -130,7 +130,7 @@ trait ValidateInterpretation extends ValidateCreation {
   /** catch and handle possible wrong values */
   def catchWrongs[R, E, A, S[_]: Applicative](effect: Eff[R, A])(handle: S[E] => Eff[R, A])(implicit member: Validate[E, *] <= R, semi: Semigroup[S[E]]): Eff[R, A] =
     intercept(effect)(new Interpreter[Validate[E, *], R, A, A] {
-      private var errs: Option[S[E]] = None
+      private[this] var errs: Option[S[E]] = None
 
       def onPure(a: A): Eff[R, A] =
         errs.map(handle).getOrElse(Eff.pure(a))