Scala: eine Trait-Methode auf eine implizite Klasse im Objekt des Elternattributs verschieben

Question

Insbesondere versuche ich meine Functor Typklasse mit Applicative zu erweitern.

trait Functor[F[_]] { 
    def fmap[A, B](r: F[A], f: A => B): F[B] 
} 

object Functor { 
    implicit class FunctorOps[A, F[_]: Functor](xs: F[A]) { 
    def fmap[B](f: A => B): F[B] = implicitly[Functor[F]].fmap(xs, f) 
    } 

    implicit def SeqFunctor: Functor[Seq] = new Functor[Seq] { 
    def fmap[A, B](r: Seq[A], f: A => B) = r map f 
    } 
} 

trait Applicative[F[_]] extends Functor[F] { 
// What I want to do, but this *does not* work. 
    def fmap[A, B](r: F[A], f: A => B): F[B] = Functor.FunctorOps[A, F](r).fmap(f) 

    def pure[A](x: A): F[A] 
    def fapply[A, B](r: F[A], f: F[A => B]): F[B] 
} 

object Applicative { 
    implicit class ApplicativeOps[A, F[_]](a: F[A])(implicit F: Applicative[F]) { 
    def fapply[B](f: F[A => B]): F[B] = F.fapply(a, f) 
    } 

    implicit def SeqApplicative: Applicative[Seq] = new Applicative[Seq] { 
    def pure[A](x: A) = Seq(x) 
    def fapply[A, B](xs: Seq[A], fs: Seq[A => B]): Seq[B] = xs.flatMap(x => fs.map(_(x))) 
    } 
} 

Der Kern ist es mir fmap für all Applicative s umsetzen müssen, aber es sollte wirklich das gleiche Verfahren, wie es in meiner FunctorOps Klasse definiert. Wie mache ich das auf die sauberste Art und Weise?

Answer 1

Sie haben den Applicative[F] <: Functor[F] Teil richtig, aber Sie sollten wirklich darüber nachdenken, was das bedeutet. Dies bedeutet, dass eine Instanz von Applicative[F]auch die Methoden für Functor[F] bereitstellt. Das heißt, Sie können nicht beide implicit val listFunctor: Functor[List]; implicit val listApplicative: Applicative[List] haben, denn dann ist der Compiler verwirrt, wenn Sie nach implicit param: Functor[List] fragen. Du solltest nur Letzteres haben. Was Sie versuchen dann unsinnig zu tun ist, weil Sie die Functor Instanz für F in Bezug auf sich selbst sind die Definition (weil die Applicative[F] sollte sein die Functor[F]), und Sie am Ende mit zwei Functor[Seq] s unabhängig.

Was Sie können tun, ist implementieren fmap in Bezug auf pure und fapply:

trait Applicative[F[_]] extends Functor[F] { 
    override def fmap[A, B](r: F[A], f: A => B): F[B] = fapply(r, pure(f)) 

    def pure[A](x: A): F[A] 
    def fapply[A, B](r: F[A], f: F[A => B]): F[B] 
} 

dann die Functor[Seq] Instanz entfernen und halten Sie Ihre Applicative[Seq], wie es ist (oder fmap überschreiben, wenn Sie möchten). Sie haben jetzt ein anderes Problem, da die implizite Suche ein bisschen umgekehrt wird, da die Instanz tatsächlich in object Applicative ist, aber das Korrigieren der impliziten Auflösung weniger mühsam ist, als die Konsistenz der separaten Instanzen Functor und Applicative zu erzwingen. In diesem Fall, wo Seq eine Art Begleiter, dessen Objekt, das Sie nicht kontrollieren können, cats zumindest etwas tut, wie

package instances { 
    trait SeqInstances { 
    implicit val seqFunctor: Functor[Seq] = ??? 
    } 
    package object seq extends SeqInstances 
    package object all extends SeqInstances 
         with AAAInstances 
         with BBBInstances 
         with ... 
} 

FYI: Ich schlage vor, Ihre typeclass Methoden

def fmap[A, B](r: F[A])(f: A => B): F[B] 
def fapply[A, B](r: F[A])(f: F[A => B]): F[B] 

und es kann currying sein schön ein flip fapply in ApplicativeOps

def ylppaf[I, B](f: F[I])(implicit ev: A =:= (I => B)) 
    : F[B] = F.fapply(a.fmap(ev))(f)