Println in Scala For-Compreansion

Question

In una compressione per la completezza, non posso semplicemente inserire una dichiarazione di stampa:

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
}

Ma posso aggirarlo facilmente con un incarico fittizio:

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
}

Essere un effetto collaterale e usato solo (finora) nel codice in fase di sviluppo, esiste una soluzione ad hoc migliore?

C'è un problema serio per cui non dovrei usarlo, oltre ad essere un effetto collaterale?

Aggiornamento che mostra il codice reale, in cui l'adattamento di una soluzione è più difficile del previsto:

Dalla discussione con Rex Kerr, la necessità è aumentata di mostrare il codice originale, che è un po 'più complicato, ma non sembrava essere rilevante per la domanda (2x .filter, chiamando un metodo alla fine), ma quando io Ho provato ad applicare il modello di Rex ho fallito, quindi lo poso qui:

  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)) }

Ecco il mio tentativo - (b * a) .filter è sbagliato, perché il risultato è un int, non una raccolta filtrabile di INT:

  // 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 parte II appartiene ai commenti, ma non può essere letto, se scritto lì - forse lo elimino alla fine. Per favore scusa.

OK - Ecco l'ultima risposta di Rex nel layout del codice:

  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))
      }
    }
  }