Println en Scala para la competencia

Question

En una competencia, no puedo simplemente poner una declaración de impresión:

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
}

Pero puedo eludirlo fácilmente con una tarea ficticia:

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
}

Siendo un efecto secundario, y solo usado (hasta ahora) en el código en desarrollo, ¿hay una mejor solución ad hoc?

¿Existe un problema grave por el que no debería usarlo, además de ser un efecto secundario?

Actualización que muestra el código real, donde adaptar una solución es más difícil de lo esperado:

De la discusión con Rex Kerr, la necesidad ha aumentado para mostrar el código original, que es un poco más complicado, pero no parecía ser relevante para la pregunta (2x .filter, llamando a un método al final), pero cuando yo Intenté aplicar el patrón Rex ', fallé, así que lo publico aquí:

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

Aquí está mi intento - (b * a) .filter es incorrecto, porque el resultado es una int, no una colección filtrable de 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 Parte II pertenece a los comentarios, pero no se puede leer, si se escribe allí, tal vez lo elimino al final. Por favor disculpe.

OK - Aquí está la última respuesta de Rex en el diseño del código:

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