Comment puis-je faire 'if..else' dans une for-comprehension?

Je pose une question très simple qui m'ont troublé récemment.
Je veux écrire un Scala Pour expression pour faire quelque chose comme ce qui suit:

for (i <- expr1) {
  if (i.method) {
    for (j <- i) {
      if (j.method) {
        doSomething()
      } else {
        doSomethingElseA()
      }
    }
  } else {
    doSomethingElseB()
  }
}

Le problème est que, dans les multiples générateurs Pour l'expression, je ne sais pas où je peux mettre chacun à l'expression du corps.

for {i <- expr1
  if(i.method) //where can I write the else logic ?
  j <- i 
  if (j.method)
} doSomething()

Comment puis-je repasser le code de la Scala de Style?

source d'informationauteur Sawyer

for-comprehension scala

17

Le premier code que vous avez écrit est parfaitement valide, donc il n'y a pas besoin de le réécrire. D'ailleurs, vous avez dit que vous vouliez savoir comment le faire Scala de style. Il n'est pas vraiment un "Scala" de style, mais je vais assumer une plus fonctionnelles de style et de tactique.
```
for (i <- expr1) {
  if (i.method) {
    for (j <- i) {
      if (j.method) {
        doSomething()
      } else {
        doSomethingElseA()
      }
    }
  } else {
    doSomethingElseB()
  }
}
```
La première préoccupation, c'est que ce ne retourne aucune valeur. Il n'est des effets secondaires, qui doivent être évités ainsi. Donc, la première modification serait comme ceci:
```
val result = for (i <- expr1) yield {
  if (i.method) {
    for (j <- i) yield {
      if (j.method) {
        returnSomething()
        //etc
```
Maintenant, il y a une grande différence entre
```
for (i <- expr1; j <- i) yield ...
```
et
```
for (i <- expr1) yield for (j <- i) yield ...
```
Leur retour des choses différentes, et il ya des moments que vous voulez le plus tard, pas l'ancien. Je vais supposer que vous voulez que l'ancienne, bien que. Maintenant, avant de poursuivre, nous allons corriger le code. Il est laid, difficile à suivre et peu utile. Nous allons à refactoriser par l'extraction de méthodes.
```
def resultOrB(j) = if (j.method) returnSomething else returnSomethingElseB
def nonCResults(i) = for (j <- i) yield resultOrB(j)
def resultOrC(i) = if (i.method) nonCResults(i) else returnSomethingC
val result = for (i <- expr1) yield resultOrC(i)
```
C'est déjà beaucoup plus propre, mais il n'est pas de retour du tout ce à quoi nous nous attendons. Regardons la différence:
```
trait Element
object Unrecognized extends Element
case class Letter(c: Char) extends Element
case class Punct(c: Char) extends Element
val expr1 = "This is a silly example." split "\\b"

def wordOrPunct(j: Char) = if (j.isLetter) Letter(j.toLower) else Punct(j)
def validElements(i: String) = for (j <- i) yield wordOrPunct(j)
def classifyElements(i: String) = if (i.nonEmpty) validElements(i) else Unrecognized
val result = for (i <- expr1) yield classifyElements(i)
```
Le type de result il est Array[AnyRef]tandis que l'utilisation de plusieurs générateurs de rendement Array[Element]. La partie la plus facile de le résoudre est: est-ce
```
val result = for {
  i <- expr1
  element <- classifyElements(i)
} yield element
```
Mais cela ne fonctionne pas, parce que classifyElements lui-même renvoie AnyRefet nous voulons le retour d'une collection. Maintenant, validElements retour d'une collection, de sorte que n'est pas un problème. Nous avons seulement besoin de fixer le else partie. Depuis validElements est au retour d'une IndexedSeqrevenons que sur le else partie. Le résultat final est:
```
trait Element
object Unrecognized extends Element
case class Letter(c: Char) extends Element
case class Punct(c: Char) extends Element
val expr1 = "This is a silly example." split "\\b"

def wordOrPunct(j: Char) = if (j.isLetter) Letter(j.toLower) else Punct(j)
def validElements(i: String) = for (j <- i) yield wordOrPunct(j)
def classifyElements(i: String) = if (i.nonEmpty) validElements(i) else IndexedSeq(Unrecognized)
val result = for {
  i <- expr1
  element <- classifyElements(i)
} yield element
```
Qui fait exactement la même combinaison de boucles et de conditions que vous avez présenté, mais il est beaucoup plus lisible et facile à changer.

Sur Le Rendement

Je pense qu'il est important de noter une chose au sujet du problème présenté. Simplifions:
```
for (i <- expr1) {
  for (j <- i) {
    doSomething
  }
}
```
Maintenant, qui est mis en œuvre avec foreach (voir iciou d'autres questions et d'y répondre). Cela signifie que le code ci-dessus fait exactement la même chose que ce code:
```
for {
  i <- expr1
  j <- i
} doSomething
```
Exactement la même chose. Ce n'est pas vrai du tout quand on est à l'aide de yield. Les expressions suivantes ne donnent pas le même résultat:
```
for (i <- expr1) yield for (j <- i) yield j

for (i <- expr1; j <- i) yield j
```
Le premier extrait sera mis en œuvre par le biais de deux map appels, tandis que la deuxième extrait de l'utilisation d'un flatMap et un map.

C'est seulement dans le contexte de yield qu'elle même n'a aucun sens de s'inquiéter sur l'imbrication des for boucles ou à l'aide de plusieurs générateurs. Et, en fait, générateurs représente le fait que quelque chose est en train généréqui est seulement vrai de vrai pour-interprétations (ceux yieldchose).
4

La partie
```
for (j <- i) {
   if (j.method) {
     doSomething(j)
   } else {
     doSomethingElse(j)
   }
 }
```
peut être réécrit comme
```
for(j <- i; e = Either.cond(j.method, j, j)) {
  e.fold(doSomething _, doSomethingElse _)  
}  
```
(bien sûr, vous pouvez utiliser un taux de rendement au lieu de cela, si votre faire.. méthodes de retourner quelque chose)

Ici, il n'est pas si terrible utile, mais si vous avez plus profondément la structure imbriquée, il pourrait...
2

Vous ne pouvez pas. L'(expr; si) construire juste de filtrer l'élément qui doit être traité dans la boucle.

import scalaz._; import Scalaz._

val lhs = (_ : List[X]) collect { case j if j.methodJ => doSomething(j) } 
val rhs = (_ : List[X]) map doSomethingElse
lhs <-: (expr1 partition methodI) :-> rhs

1

Si l'ordre n'est pas important pour les appels à doSomething() et doSomethingElse (), alors vous pouvez réorganiser le code comme ceci.
```
val (tmp, no1) = expr1.partition(_.method)
val (yes, no2) = tmp.partition(_.method)

yes.foreach(doSomething())
no1.foreach(doSomethingElse())
no2.foreach(doSomethingElse())
```
Pour répondre à votre question initiale, je pense que pour les interprétations peuvent être très agréable pour des cas d'utilisation spécifiques, et votre exemple ne tient pas bien.
0

Les conditions spécifiées dans un Scala pour l'opération de la loi de filtrer les éléments de générateurs. Les éléments qui ne remplit pas les conditions sont ignorés et ne sont pas présentés pour le rendement /bloc de code.

Ce que cela signifie est que si vous voulez effectuer suppléant opérations basée sur une expression conditionnelle, le test doit être différées au rendement /bloc de code.

Aussi être conscient que l'opération est relativement onéreux (pour l'instant) donc peut-être une simple approche itérative, peut-être plus approprié, peut-être quelque chose comme:
```
expr1 foreach {i =>
  if (i.method) {
    i foreach {j =>
      if (j.method)
        doSomething()
      else
        doSomethingElseA()
    }
  }
  else
    doSomethingElseB()
}
```
Mise à jour:

Si vous devez en utiliser un pour la compréhension et vous pouvez vivre avec certaines restrictions, cela peut fonctionner:
```
for (i <- expr1; j <- i) {
  if (i.method) {if (j.method) doSomething() else doSomethingElseA()} else doSomethingElseB()
}
```

Vous devez vous connecter pour publier un commentaire.