Scala kann nicht NaturalTransformation in scalaz oder Katzen

Question

Aus irgendeinem Grund aufmotzen die folgenden nicht

object NtExtTest { 
    implicit class NaturalTransformExt[M[_], N[_]](val self: NaturalTransformation[M,N]) extends AnyVal { 
    def test(b:Boolean) = b 
    } 
} 

arbeiten, wenn ich die Methode test auf einem natürlichen nennen. Intellij erkennt es als eine Erweiterungsfunktion, aber die Kompilierung gibt value test is not a member of cats.~>. Das gleiche passiert bei Verwendung der scalaz NaturalTransformation. Kann ich etwas tun, damit die Kompilierung die Erweiterung erkennt?

Scala Version 2.11.8

Ein Beispiel, das fehlschlägt:

import NtExtTest._ 

    class NtTest[B] extends NaturalTransformation[Either[B,?], Xor[B,?]] { 
    def apply[A](fa: Either[B, A]): Xor[B, A] = { 
     fa match { 
     case Left(l) => Xor.left(l) 
     case Right(r) => Xor.right(r) 
     } 
    } 
    } 

    val test = new NtTest[String] 
    test.test(false) 

(oben verwendet Art Projektor-Plugin, aber auch nicht mit Typ lambdas oder einzelnen param höher kinded Typen)

Answer 1

bezieht sich wahrscheinlich auf SI-8286

object NtExtTest { 
    // this will work 
    implicit class NatTransExt1[E](val t: NaturalTransformation[Either[E, ?], \/[E, ?]]) { 
    def test1(b: Boolean): Boolean = false 
    } 

    // and this will work 
    implicit class NatTransExt2[E](val t: NtTest[E]) { 
    def test2(b: Boolean): Boolean = false 
    } 

    // but this will not work, because NaturalTransformation[F, G] and 
    // NaturalTransformation[Either[E, ?], \/[E, ?]] of different kind 
    implicit class NatTransExt3[F[_], G[_]](val s: NaturalTransformation[F, G]) { 
    def test3(b: Boolean): Boolean = false 
    } 
} 

es ist nicht verwandt mit NaturalTransformation. Es funktioniert nicht so gut in einfachen Fall arbeiten:

trait SomeType[F[_]] 

class SomeConcreteType[A] extends SomeType[Either[A, ?]] 

object SomeTypeExt { 
    // this will not compile 
    implicit class SomeTypeEnrich[F[_]](val t: SomeType[F]) { 
    def test1: Boolean = false 
    } 
    // this will 
    implicit class SomeConcreteEnrich[A](val t: SomeType[Either[A, ?]]) { 
    def test2: Boolean = true 
    } 
} 

Wenn das Ziel NtTest zu verlängern, würde wahrscheinlich NatTransExt1 beste Wahl, wenn man möge so allgemein wie möglich bleiben. NatTransExt2 ist in Ordnung, wenn die Erweiterung wirklich spezifisch für NtTest ist.