Perché non riesco a flatMap a Try?

Question

Dato

val strings = Set("Hi", "there", "friend") 
def numberOfCharsDiv2(s: String) = scala.util.Try { 
    if (s.length % 2 == 0) s.length/2 else throw new RuntimeException("grr") 
} 

Perché non posso flatMap via la Prova risultante dalla chiamata di metodo? vale a dire

strings.flatMap(numberOfCharsDiv2) 
<console>:10: error: type mismatch; 
found : scala.util.Try[Int] 
required: scala.collection.GenTraversableOnce[?] 
       strings.flatMap(numberOfCharsDiv2) 

o

for { 
    s <- strings 
    n <- numberOfCharsDiv2(s) 
} yield n 
<console>:12: error: type mismatch; 
found : scala.util.Try[Int] 
required: scala.collection.GenTraversableOnce[?] 
      n <- numberOfCharsDiv2(s) 

Tuttavia se uso opzione invece di Prova non c'è nessun problema.

def numberOfCharsDiv2(s: String) = if (s.length % 2 == 0) 
    Some(s.length/2) else None 
strings.flatMap(numberOfCharsDiv2) # => Set(1, 3) 

Qual è la logica alla base del non consentire flatMap su Prova?

Answer 1

guardiamo la firma di flatMap.

def flatMap[B](f: (A) => GenTraversableOnce[B]): Set[B] 

tuo numberOfCharsDiv2 è visto come String => Try[Int]. Try non è una sottoclasse di GenTraversableOnce ed è per questo che si ottiene l'errore. Non è strettamente necessario una funzione che fornisce un valore Set solo perché si utilizza flatMap su un Set. La funzione deve fondamentalmente restituire qualsiasi tipo di raccolta.

Quindi perché funziona con Option? Option non è una sottoclasse di GenTraversableOnce, ma esiste una conversione implicita all'interno dell'oggetto complementare Option, che lo trasforma in List.

implicit def option2Iterable[A](xo: Option[A]): Iterable[A] = xo.toList 

Quindi rimane una domanda. Perché non avere una conversione implicita per Try? Perché probabilmente non otterrai quello che vuoi.

flatMap può essere visto come map seguito da un flatten.

Immagina di avere un List[Option[Int]] come List(Some(1), None, Some(2)). Quindi flatten ti darà List(1,2) di tipo List[Int].

Ora guarda un esempio con Try. List(Success(1), Failure(exception), Success(2)) di tipo List[Try[Int]].

Come si appiattirà ora l'errore?

• Dovrebbe scomparire come None? Allora perché non lavorare direttamente con Option?
• Dovrebbe essere incluso nel risultato? Quindi sarebbe List(1, exception, 2). Il problema qui è che il tipo è List[Any], perché devi trovare una super classe comune per Int e Throwable. Si perde il tipo.

Queste dovrebbero essere le ragioni per cui non esiste una conversione implicita. Ovviamente sei libero di definirne uno tu stesso, se accetti le conseguenze di cui sopra.

Answer 2

Il problema è che nel tuo esempio, non stai pianeggiando su Prova. La flatmap che stai facendo è su Set.

Flatmap su Set prende un Set [A] e una funzione da A a Set [B]. Come Kígyó sottolinea nel suo commento qui sotto non è questa la firma tipo effettivo di flatmap su Set in Scala, ma la forma generale di carta piatta è:

M[A] => (A => M[B]) => M[B]

Cioè, ci vuole un po più alto kinded digita, insieme a una funzione che opera su elementi del tipo in quel tipo di tipo più alto, e ti restituisce lo stesso tipo di tipo più alto con gli elementi mappati.

Nel tuo caso, questo significa che per ogni elemento del tuo Set, flatmap si aspetta una chiamata a una funzione che accetta una stringa e restituisce un Set di qualche tipo B che potrebbe essere String (o potrebbe essere qualsiasi altra cosa).

La funzione

numberOfCharsDiv2(s: String) 

prende correttamente una stringa, ma in modo non corretto restituisce una prova, piuttosto che un altro insieme come flatmap richiede.

Il tuo codice funzionerebbe se tu avessi usato 'mappa', dato che ti permette di prendere qualche struttura - in questo caso Imposta ed esegui una funzione su ogni elemento trasformandolo da A a B senza il tipo di ritorno della funzione conforme a la struttura racchiude cioè la restituzione di un set

strings.map(numberOfCharsDiv2)

res2: scala.collection.immutable.Set[scala.util.Try[Int]] = Set(Success(1), Failure(java.lang.RuntimeException: grr), Success(3))