redes - grabado en scala para-comprensión

informacion mediatica

Question

En una comprensión, no puedo simplemente poner una declaración impresa:

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

Al ser un efecto secundario, y solo utilizado (hasta ahora) en el código en desarrollo, ¿existe una mejor solución ad hoc?

¿Hay 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 la adaptación de una solución es más difícil de lo esperado:

De la discusión con Rex Kerr, se ha incrementado la necesidad de mostrar el código original, que es un poco más complicado, pero no pareció ser relevante para la pregunta (2x .filter, que llama un método al final), pero cuando Intenté aplicarle el patrón de 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 un int, no una colección de ints filtrable:

  // 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 puede leerse, si está escrita allí, tal vez la elimine 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))
      }
    }
  }

Answer 1

Así es como necesitas escribirlo:

scala> 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
     | }
prod: (m: Int)scala.collection.immutable.IndexedSeq[Int]

scala> prod(20)
2 3 res159: scala.collection.immutable.IndexedSeq[Int] = Vector(6, 8, 10, 12, 14
, 16, 18, 12, 15, 18)

Answer 2

No parece ser un buen estilo colocar una declaración de efectos colaterales dentro de una comprensión (o incluso en el medio de cualquier función), excepto por la depuración, en cuyo caso realmente no importa cómo se llame ("depuración "parece un buen nombre).

Si realmente lo necesita, creo que sería mejor que separa sus inquietudes de alguna manera asignando un valor intermedio, por ejemplo (su original está más bien definido):

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

se convierte en

  def prod2 (p: Array[Boolean], max: Int) = {
    val as = (2 to max / (2 * 3)) filter p

    for(a <- as) print(a + "  ")

    as flatMap {a => 
      for {
        b <- ((a + 1) to max / a) filter p
        if a * b <= max
      } yield em(a, b, max)
    }
  }

Answer 3

Por lo general, el estilo de codificación me resulta bastante difícil de seguir, ya que los bucles y los resultados intermedios se mezclan entre sí. Yo, en lugar de un bucle for, escribiría algo así como

def prod(m: Int) = {
  (2 to m/(2*3)).flatMap { a =>
    print(a + " ")
    ((a+1) to m/a).map(_ * a).filter(_ < m)
  }
}

Esto también hace que agregar declaraciones impresas y así sea más fácil.