Scala Future seltsame Kompilierfehler

Question

Code unten ist eine vereinfachte Version des echten Codes. Wir haben das Domänenmodell case object FutTest und case class FutTest "geerbt", das wir nicht ändern können. Die tatsächlichen Domänenmodelle werden von einer Datenbank bedient, so glaube ich, dass die gültig ist, aber es verursacht Probleme, die ich nicht verstehe.

import org.scalatest.FunSpec 
import scala.concurrent.Future 
import scala.concurrent.ExecutionContext.Implicits.global 

case object FutTest { 
    def create(sz: Int) = { FutTest(sz) } 
} 

case class FutTest(size: Int) 

class FutureTest extends FunSpec { 
    def one(v: Int): Future[FutTest] = { 
    Future { FutTest.create(v) } 
    } 
    def two(t: FutTest) = { 
    Future { FutTest.create(t.size) } 
    } 

    def compileError1: Future[FutTest] = { 
    one(10).map(f => two(f)) 
    } 

    def compileError2: Future[FutTest] = { 
    for { o <- one(10) } yield (two(o)) 
    } 
} 

Die Fehlermeldungen:

[INFO] Using incremental compilation 
[INFO] Compiling 7 Scala sources and 5 .. target/test-classes... 
[ERROR] domain.FutureTest.scala:25: type mismatch; 
found : scala.concurrent.Future[domain.FutTest] 
required: domain.FutTest 
[ERROR]  one(10).map(f => two(f)) 
[ERROR]      ^
[ERROR] domain/FutureTest.scala:29: type mismatch; 
found : scala.concurrent.Future[domain.FutTest] 
required: domain.FutTest 
[ERROR]  for { o <- one(10) } yield (two(o)) 

habe ich versucht, den obigen Code mit einfachen Int statt FutTest und alles ist in Ordnung. Warum beschwert sich der Compiler und wie können wir das lösen, ohne die bestehende Domain zu berühren?

Answer 1

flatMap ist was Sie wollen.

one(10).flatMap(f => two(f)) 

oder

one(10).flatMap(two) 

Verwendung für das Verständnis,

for { o <- one(10); t <- two(o) } yield t 

Answer 2

One() gibt ein Future und two() gibt auch ein Future, so dass Sie flatMap statt map müssen. Wenn Sie auf two() abbilden, ist Ihr Ergebnis Future[Future[FutTest]] und muss abgeflacht werden.

Doing

one(10).flatMap(f => two(f)) 

sollte es tun.