println dans Scala pour compréhension

Question

Dans une compréhension, je ne peux pas simplement mettre une déclaration d'impression:

def prod (m: Int) = {
  for (a <- 2 to m/(2*3);
    print (a + "  ");
    b <- (a+1) to m/a;
    c = (a*b) 
    if (c < m)) yield c
}

Mais je peux le contourner facilement avec une affectation factice:

def prod (m: Int) = {
  for (a <- 2 to m/(2*3);
    dummy = print (a + "  ");
    b <- (a+1) to m/a;
    c = (a*b) 
    if (c < m)) yield c
}

Étant un effet secondaire et uniquement utilisé (jusqu'à présent) dans le code en cours de développement, y a-t-il une meilleure solution ad hoc?

Y a-t-il un problème grave pourquoi je ne devrais pas l'utiliser, en plus d'être un effet secondaire?

Mise à jour montrant le code réel, où l'adaptation d'une solution est plus difficile que prévu:

D'après la discussion avec Rex Kerr, la nécessité a augmenté pour montrer le code d'origine, qui est un peu plus compliqué, mais ne semblait pas être pertinent pour la question (2x .Filtre, appelant une méthode à la fin), mais quand je J'ai essayé d'appliquer le modèle REX, j'ai échoué, alors je le poste ici:

  def prod (p: Array[Boolean], max: Int) = {
    for (a <- (2 to max/(2*3)).
        filter (p);
      dummy = print (a + "  ");
      b <- (((a+1) to max/a).
         filter (p));
      if (a*b <= max)) 
        yield (em (a, b, max)) }

Voici ma tentative - (b * a). Le filtre est faux, car le résultat est un INT, pas une collection filtrable d'INTS:

  // wrong: 
  def prod (p: Array[Boolean], max: Int) = {
    (2 to max/(2*3)).filter (p).flatMap { a =>
      print (a + " ")
      ((a+1) to max/a).filter (p). map { b => 
        (b * a).filter (_ <= max).map (em (a, b, max))
      }
    }
  }

La partie II appartient aux commentaires, mais ne peut pas être lue, si je suis écrite là-bas - peut-être que je le supprime à la fin. Veuillez excuser.

OK - voici Rex la dernière réponse dans la mise en page du code:

  def prod (p: Array[Boolean], max: Int) = {
    (2 to max/(2*3)).filter (p).flatMap { a =>
      print (a + " ")
      ((a+1) to max/a).filter (b => p (b) 
        && b * a < max).map { b => (m (a, b, max))
      }
    }
  }