2013-05-07 5 views
15

Il me semble que le NonEmptyList de Scalaz a une instance de monad, donc un transformateur de monade pour lui (un peu semblable à ListT) devrait être possible. Est-ce exact?Transformateur Monad pour NonEmptyList?

Si oui, y en a-t-il un là-bas? (Je ne pouvais pas en trouver un dans Scalaz 7 lui-même.)

Si ce n'est pas le cas, par exemple un transformateur monad pour cela serait impossible ou n'a aucun sens, je vous serais reconnaissant pour toute explication supplémentaire quant à pourquoi pas.

+0

Je peux faire la suggestion que vous devriez essayer de créer un et contribuer! –

+0

C'était absolument mon plan. = ^.^= Mais je voulais éviter d'essayer d'implémenter quelque chose qui ne fonctionne pas par principe. NEL semble un peu «largement» utilisé, donc j'attribuais la non-existence d'un transformateur monade à quelque chose que je ne saisis pas (encore) au lieu de (simplement) «personne n'a trouvé le temps de le faire encore». –

+1

Le meilleur moyen est souvent d'essayer comme d'habitude si c'est impossible, cela sera évident quelque peu immédiatement. :) –

Répondre

4

Il est certainement possible, car il peut être démontré que toute monade qui a une instance Traverse peut être transformé en un transformateur monade:

import scalaz._ 
import Scalaz._ 

object MonadT { 
    implicit def monadTransformerFromTraverse[M[_]: Monad, N[_]: Monad: Traverse]: Monad[({type MN[A]=M[N[A]]})#MN] = new Monad[({type MN[A]=M[N[A]]})#MN] { 
    def point[A](a: => A): M[N[A]] = a.point[N].point[M] 
    def bind[A,B](fa: M[N[A]])(f: A=>M[N[B]]) : M[N[B]] = { 
     val M = implicitly[Monad[M]] 
     val NT = implicitly[Traverse[N]] 
     val N = implicitly[Monad[N]] 

     M.map(M.join(M.map(M.map(fa)(N.map(_)(f)))(NT.sequence(_))))(N.join) 
//      |- => M[N[M[N[B]]]] -| 
//     |-  => M[M[N[N[B]]]]     -| 
//   |-    => M[N[N[B]]]      -| 
// |-     => M[N[B]]         -| 


    } 
    } 

    def main(argv: Array[String]) { 
    val x: Option[NonEmptyList[Int]] = Some(NonEmptyList(1)) 
    val f: Int => Option[NonEmptyList[Int]] = { x: Int => Some(NonEmptyList(x+1)) } 

    val MT = monadTransformerFromTraverse[Option, NonEmptyList] 
    println(MT.bind(x)(f)) // Some(NonEmptyList(2)) 
    } 
} 

Ceci est clairement pas la forme la plus commode de travailler avec, mais montre que c'est, en effet, possible. Tom Switzer travaille actuellement à l'ajout d'un transformateur Monad TraverseT beaucoup plus utile et générique à Scalaz. Vous pouvez see his progress on GitHub

Questions connexes