幫我把這個理解力右

Question

我有以下的（工作）代碼

val superSuperSorts = superSorts.flatMap(relations.get(_)).flatMap(x=>x) 

而且我給你這裏的類型

val superSorts: Set[Sort] 
val relations: Map[Sort, Set[Sort]] 

它更改爲這個換的理解給了我一個編譯該讀數的誤差

val superSuperSorts = 
    for(
    ss <- superSorts; 
    sss <- relations.get(ss); //get Option[Set[Sort]] and flatten the option 
    s <- sss     //extract the elements from the Set 
) yield s 

error: type mismatch; 
found : scala.collection.immutable.Set[edu.uulm.scbayes.logic.Sort] 
required: Option[?] 
s <- sss 

請解釋爲什麼我的理解錯誤。

Answer 1

您不能flatMap一個選項。看看它的類型簽名：

def flatMap [B] (f: (A) ⇒ Option[B]): Option[B] 

所以，flatMap解壓選項，但需要一個新的選項，所以你需要一個替代。您可以使用地圖選項的方法getOrElse或方法seq：

val superSuperSorts = for { 
    s <- superSorts 
    ss <- relations.getOrElse(s, Set.empty) 
} yield s 

val superSuperSorts = for { 
    s <- superSorts 
    ss <- relations.get(s).seq 
    sss <- ss 
} yield sss 

的另一個問題是，你flatMap代碼不等於用你的表達。表達

for (x <- expr1; y <- expr2) yield expr3 

被翻譯成

expr1.flatMap(x => for (y <- expr2) yield expr3) 

，並在另一個步驟

expr1.flatMap(x => expr2.map(y => expr3)) 

但是你必須：

expr1.flatMap(x => expr2).flatMap(y => expr3) 

Answer 2

重要的是要明白，一個用於理解會產生類型的收集fed。因此，爲什麼你的代碼不工作是你想返回一個單一的元素。試試這個：

val superSuperSorts = 
  for(
  ss <- superSorts; 
  sss <- relations.get(ss); //get Option[Set[Sort]] and flatten the option 
) yield sss 

：/希望這有助於

Answer 3

讓我舉一個例子來弄清楚問題出在哪裏。比方說，你有：

val superSorts = Set('x) 
val relations = Map('x -> Set('a, 'b)) 

此代碼：

val superSuperSorts = 
    for(
    ss <- superSorts; 
    sss <- relations.get(ss); //get Option[Set[Sort]] and flatten the option 
    s <- sss     //extract the elements from the Set 
) yield s 

翻譯爲：

superSorts.flatMap(
    ss => relations.get(ss).flatMap(
    sss => sss.map(
     s => s))) 

首先，請注意，最後一項是map，而不是一個flatMap。現在，讓我們考慮用以上數據進行迭代：

ss = 'x 
sss = Set('a, 'b) 
s = 'a, 'b 

現在讓我們在代碼中向後走。

// Set('a, 'b) => Set('a, 'b) 
sss.map(s => s) 

// Some(Set('a, 'b)) => Some('a, 'b)???? 
relations.get(ss).flatMap(...) 

看到問題在這裏？ Option[Set[Sort]]如何平展？有沒有這樣的事情作爲Some('a, 'b)。

那麼，爲什麼原始代碼工作？

val superSuperSorts = superSorts.flatMap(relations.get(_)).flatMap(x=>x) 

如果我們把它分解：

// Set('x) => Set(Set('a, 'b)) 
superSorts.flatMap(relations.get(_)) 

// Set(Set('a, 'b')) => Set('a, 'b) 
(...).flatMap(x=>x) 

就能查看所有的flatMap被應用在Set，不是Option？ Option被flatMap淘汰，從未發揮過作用。

的更多或更少的等價物，理解您的代碼將是：

val superSuperSorts = for { 
    x <- (for { 
    ss <- superSorts 
    sss <- relations.get(ss) 
    } yield sss) 
    s <- x 
} yield s 

這引入了幾個身份地圖：map(sss => sss)和map(s => s)，該回避的事實得到，在一個最後的發電機理解總是一個map。