Was ist der deal mit allen Entweder Reste?

Jeder Klasse sinnvoll erscheint und die Möglichkeiten der Verwendung es sind ziemlich offensichtlich. Aber dann schaue ich auf die API-Dokumentation, und ich bin verblüfft:

def joinLeft [A1 >: A, B1 >: B, C] (implicit ev: <:<[A1, Either[C, B1]]):
         Either[C, B1]
   Joins an Either through Left.

def joinRight [A1 >: A, B1 >: B, C] (implicit ev: <:<[B1, Either[A1, C]]):
         Either[A1, C]
   Joins an Either through Right.

def left : LeftProjection[A, B]
   Projects this Either as a Left.

def right : RightProjection[A, B]
   Projects this Either as a Right.

Was mache ich mit einer Projektion und wie kann ich selbst aufrufen den Beitritt?

Google nur Punkte die mir auf die API-Dokumentation.

Kann dies nur ein Fall von "keine Aufmerksamkeit auf den Mann hinter dem Vorhang", aber ich denke nicht so. Ich glaube, das ist wichtig.

Obligatorischen Hinweis, dass Try ist Häufig einfacher zu verwenden als Either für exception handling, aber es war nicht verfügbar vor dem Scala 2.10. [scala-lang.org/api/current/scala/util/Try.html]

InformationsquelleAutor Malvolio | 2011-08-20

scala

50

left und right sind die wichtigsten. Either ist nützlich, ohne Projektionen (meist tun Sie pattern-matching), sondern Projektionen sind, durchaus Aufmerksamkeit verdient, als Sie geben eine viel reichere API. Verwenden Sie verbindet viel weniger.

Either wird oft verwendet, um zu bedeuten, "einen richtigen Wert oder ein Fehler". In dieser Hinsicht ist es wie eine erweiterte Option . Wenn keine Daten vorhanden sind, statt None Sie haben einen Fehler.
Option hat eine umfangreiche API. Das gleiche kann zur Verfügung gestellt werden, die auf Either, vorausgesetzt, wir wissen,,, was ist das Ergebnis und welches ist der Fehler.

left und right Projektion sagt nur, dass. Es ist die Either, plus dem zusätzlichen wissen, dass der Wert jeweils Links oder rechts, und der andere ist der Fehler.

Beispielsweise in Option können Sie anzeigen, so opt.map(f) gibt ein Option mit f angewendet, um den Wert von opt wenn es eine eins, und noch None wenn opt war None. Auf der linken Projektion, es gilt f auf den value-at-Links, wenn es ein Left, und lassen Sie es unverändert, wenn es eine Right. Beachten Sie die Signaturen:
- In LeftProjection[A,B], map[C](f: A => C): Either[C,B]
- In RightProjection[A,B], map[C](f: B => C): Either[A,C].
left und right sind einfach die Art und Weise zu sagen, die Seite ist als der Wert, wenn Sie verwenden möchten, eine der üblichen API-Routinen.

Alternativen hätte:
- set eine Konvention, als in Haskell, wo es starke syntaktische Gründe, um den Wert zu Recht. Wenn Sie möchten, anwenden einer Methode auf die andere Seite (Sie können auch ändern wollen, den Fehler mit einem map zum Beispiel), tun ein swap vor und nach.
- postfix-Methode-Namen mit Links oder Rechts (vielleicht auch nur L und R). Das würde verhindern, dass die Verwendung für das Verständnis. Mit for Verstehens (flatMap in der Tat, aber die für die notation ist sehr bequem) Either ist eine alternative für (checked) exceptions.
Nun die verbindet. Links und Rechts bedeutet das gleiche wie für die Projektionen, und Sie sind eng mit flatMap. Betrachten joinLeft. Die Unterschrift kann verwirrend sein:
```
joinLeft [A1 >: A, B1 >: B, C] (implicit ev: <:<[A1, Either[C, B1]]):
         Either[C, B1]
```
A1 und B1 sind technisch notwendig, aber nicht entscheidend für das Verständnis, wir vereinfachen
```
joinLeft[C](implicit ev: <:<[A, Either[C, B])
```
Was implizit bedeutet, dass die Methode kann nur aufgerufen werden, wenn A ist ein Either[C,B]. Die Methode ist nicht auf eine Either[A,B] im Allgemeinen, sondern nur auf eine Either[Either[C,B], B]. Als mit der linken Projektion, betrachten wir, dass der Wert auf der linken Seite (das wäre das richtige für joinRight). Was die Verknüpfung tut, ist, glätten Sie diese (denke flatMap). Wenn man mitmachen, man kümmert sich nicht, ob der Fehler (B) innen oder außen, wir wollen nur, dass Entweder[C,B]. Also Links(Links(c)) ergibt sich Links(c), Links(Rechts(b)) und Rechten(b) Ausbeute Rechts(b). Die Beziehung mit flatMap ist wie folgt:
```
joinLeft(e) = e.left.flatMap(identity)
e.left.flatMap(f) = e.left.map(f).joinLeft
```
Den Option gleichwertig funktionieren würde, auf ein Option[Option[A]], Some(Some(x)) ergeben würde Some(x) beide Some(None) und None ergeben würde None. Es kann geschrieben werden a -.flatMap(Identität). Beachten Sie, dass Option[A] ist isomorph zu Either[A,Unit] (wenn Sie verwenden Sie die Links Projektionen und joins) und auch Either[Unit, A] (mit Recht Hochrechnungen).

InformationsquelleAutor Didier Dupont
20

Ignorieren die Verknüpfungen für jetzt, Projektionen sind ein Mechanismus, so dass Sie verwenden Sie verwenden Sie eine Either als Monade. Betrachten Sie es als die Extraktion entweder auf der linken oder auf der rechten Seite in eine Option, aber , ohne die andere Seite

Wie immer, das wohl mehr Sinn macht, mit einem Beispiel. So stellen Sie sich vor Sie haben eine Either[Exception, Int] und konvertieren wollen die Exception zu einem String (falls vorhanden)
```
val result = opReturningEither
val better = result.left map {_.getMessage}
```
Diese Karte wird über die linke Seite führen, so dass Sie eine Either[String,Int]
- Ihre Ideen faszinieren mich und ich wünschte, um Ihre newsletter zu abonnieren.
- Neugierig... Wie viel wären Sie bereit zu zahlen?
InformationsquelleAutor Kevin Wright
14

joinLeft und joinRight aktivieren Sie "glätten" einer geschachtelten Either:
```
scala> val e: Either[Either[String, Int], Int] = Left(Left("foo"))
e: Either[Either[String,Int],Int] = Left(Left(foo))

scala> e.joinLeft
res2: Either[String,Int] = Left(foo)
```
Edit: Meine Antwort auf diese Frage zeigt ein Beispiel, wie man mit Hilfe der Projektionen, in diesem Fall Falten Sie zusammen eine Folge von Eithers ohne pattern-matching oder rufen isLeft oder isRight. Wenn Sie vertraut sind mit der Verwendung Option ohne Abgleich oder die Berufung isDefined es analagous.

Während Sie neugierig mit Blick auf die aktuelle Quelle Entweder, sah ich, dass joinLeft und joinRight implementiert, mit pattern-matching. Allerdings stolperte ich über diese ältere version der source und sah, dass es um die Umsetzung der join-Methoden unter Verwendung von Projektionen:
```
def joinLeft[A, B](es: Either[Either[A, B], B]) =
  es.left.flatMap(x => x)
```
- Was ist der use case für eine verschachtelte Entweder?
- Es ist nicht so, dass Sie vielleicht wollen, ist es, dass Sie möglicherweise, und mitmachen können Sie, um es loszuwerden. Angenommen, Sie haben eine Funktion auf irgendeine Art von generischen container Ein, die zurückkehren würde, verwendet man Entweder[A,E], weil es eine Möglichkeit des Scheiterns. Angenommen, Ihre insbesondere enthält der Behälter Entweder[YourData, E], denn die Daten sind das Ergebnis eines Prozesses, kann fehlschlagen, zu. Dann bekommst du Entweder ein[Entweder[YourData, E], E], und Sie vielleicht beitreten möchten, weil Sie sich nicht sorgen, ob der Fehler passiert, wenn die Daten, die gebaut wurden (innere) oder abgerufen (äußere).
InformationsquelleAutor Ben James

Mein Vorschlag ist, fügen Sie den folgenden, um Ihre utility-Paket:

implicit class EitherRichClass[A, B](thisEither: Either[A, B])
{
   def map[C](f: B => C): Either[A, C] = thisEither match
   {
     case Left(l) => Left[A, C](l)
     case Right(r) => Right[A, C](f(r))
   }
   def flatMap[C](f: B => Either[A, C]): Either[A, C] = thisEither match
   {
     case Left(l) => Left[A, C](l)
     case Right(r) => (f(r))
   }
}

Meiner Erfahrung nach die einzig sinnvolle Methode ist, Falten. Sie nicht wirklich nutzen isLeft oder isRight in funktionalen code. joinLeft und joinRight könnte nützlich sein, als flatten Funktionen wie erläutert durch Dider Dupont, aber ich hatte noch keine Gelegenheit, Sie zu benutzen auf diese Weise. Das oben genannte ist die Verwendung Entweder als Recht voreingenommen, was ich vermute, ist, wie die meisten Menschen Sie verwenden. Es ist wie eine Option mit einem Fehlerwert statt None.

Hier sind einige von meinen eigenen code. Entschuldigt, das Ihr nicht Poliert-code, aber seine ein Beispiel für die Verwendung Entweder in einem für das Verständnis. Die Zugabe der map-und flatMap-Methoden erlaubt uns, verwenden die Besondere syntax, die für Verstehens. Seine Analyse der HTTP-Header, entweder durch Rückgabe eines Http-und Html-Fehler-Seite-Antwort oder ausgewertete benutzerdefinierte HTTP-Request-Objekt. Ohne die Verwendung der für das Verständnis der code wäre sehr schwer zu begreifen.

object getReq
{      
  def LeftError[B](str: String) = Left[HResponse, B](HttpError(str))
  def apply(line1: String, in: java.io.BufferedReader): Either[HResponse, HttpReq] = 
  {
    def loop(acc: Seq[(String, String)]): Either[HResponse, Seq[(String, String)]] =
    {
      val ln = in.readLine
      if (ln == "")
        Right(acc)         
      else
        ln.splitOut(':', s => LeftError("400 Bad Syntax in Header Field"), (a, b) => loop(acc :+ Tuple2(a.toLowerCase, b)))
    }

    val words: Seq[String] = line1.lowerWords

    for
    {
      a3 <- words match
      {
        case Seq("get", b, c) => Right[HResponse, (ReqType.Value, String, String)]((ReqType.HGet, b, c))
        case Seq("post", b, c) => Right[HResponse, (ReqType.Value, String, String)]((ReqType.HPost, b, c))
        case Seq(methodName, b, c) => LeftError("405" -- methodName -- "method not Allowed")
        case _ => LeftError("400 Bad Request: Bad Syntax in Status Line")
      }
      val (reqType, target, version) = a3
      fields <- loop(Nil)
      val optLen = fields.find(_._1 == "content-length")
      pair <- optLen match
      {
        case None => Right((0, fields))
        case Some(("content-length", second)) => second.filterNot(_.isWhitespace) match
        {
          case s if s.forall(_.isDigit) => Right((s.toInt, fields.filterNot(_._1 == "content-length")))
          case s => LeftError("400 Bad Request: Bad Content-Length SyntaxLine")
        }
      }
      val (bodyLen, otherHeaderPairs) = pair
      val otherHeaderFields = otherHeaderPairs.map(pair => HeaderField(pair._1, pair._2))
      val body = if (bodyLen > 0) (for (i <- 1 to bodyLen) yield in.read.toChar).mkString else ""         
    }      
    yield (HttpReq(reqType, target, version, otherHeaderFields, bodyLen, body))
  }   
}

InformationsquelleAutor Rich Oliver

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.