Ist es eine Monade versuchen, wenn Einheit = Erfolg?

Question

Mit unit = Try, Try ist keine Monade, weil die linke Einheit Gesetz scheitert.

Try(expr) flatMap f != f(expr) 

Aber was ist die Frage wird: Ist es Try eine Monade, wenn unit = Success?

In diesem Fall:

Success(expr) flatMap f == f(expr) 

So ist es eine Monade.

Ist mein Verständnis korrekt?

Answer 1

Erhalten Sie eine Antwort von der Hilfe von Alexey im Coursera Forum:

Wenn unit = Success, für die linke Einheit Gesetz:

Success(throw new Exception) flatMap f == f(throw new Exception) // holds 
Success(s) flatMap (x => throw new Exception) == Failure(new Exception) // does not hold 

Es verliert tatsächlich wieder, außer natürlich, Sie neu definieren flatMap die Ausnahmen neu zu werfen, so dass die Hauptfunktionalität der Try

Answer 2

Im Wesentlichen ja. Normalerweise werden Monaden in einer rein funktionalen Sprache definiert, in der Gleichheit == die üblichen Eigenschaften der Gleichheit hat, d. H. Wir können Gleiche für Gleichgestellte ersetzen. Wenn Sie innerhalb einer solchen Teilmenge von Scala sind, dann können Sie tatsächlich eine natürliche Definition eines parametrischen Typs geben, der möglicherweise außergewöhnliche Berechnungen darstellt. Hier ist ein Beispiel. Das Beispiel passiert tatsächlich mechanisch im Leon-Verifikationssystem für Scala (http://leon.epfl.ch).

import leon.lang._ 
object TryMonad { 

    // Exception monad similar to Option monad, with an error message id for None 
    sealed abstract class M[T] { 
    def bind[S](f: T => M[S]): M[S] = { 
     this match { 
     case Exc(str) => Exc[S](str) 
     case Success(t) => f(t) 
     } 
    } 
    } 
    case class Exc[T](err: BigInt) extends M[T] 
    case class Success[T](t: T) extends M[T] 

    // unit is success 
    def unit[T](t:T) = Success(t) 

    // all laws hold 
    def leftIdentity[T,S](t: T, f: T => M[S]): Boolean = { 
    unit(t).bind(f) == f(t) 
    }.holds 

    def rightIdentity[T](m: M[T]): Boolean = { 
    m.bind(unit(_)) == m 
    }.holds 

    def associativity[T,S,R](m: M[T], f: T => M[S], g: S => M[R]): Boolean = { 
    m.bind(f).bind(g) == m.bind((t:T) => f(t).bind(g)) 
    }.holds 
}