30

为了便于理解，我不能只写一个打印语句：

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
}

但我可以通过虚拟分配轻松绕过它：

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
}

作为一个副作用，并且（到目前为止）仅用于正在开发的代码中，是否有更好的临时解决方案？

除了副作用之外，为什么我不应该使用它有什么严重的问题吗？

更新显示真实代码，其中适应一种解决方案比预期更难：

从与 Rex Kerr 的讨论来看，有必要展示原始代码，这有点复杂，但似乎与问题无关（2x .filter，最后调用一个方法），但是当我尝试将 Rex 的模式应用于它我失败了，所以我在这里发布：

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

这是我的尝试—— (b * a).filter 是错误的，因为结果是一个 int，而不是一个可过滤的 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))
      }
    }
  }

第二部分属于评论，但无法阅读，如果写在那里-也许我最后将其删除。请包涵。

好的 - 这是 Rex 在代码布局中的最后一个答案：

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

4 回答 4

46

这就是您需要编写它的方式：

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)
于 2011-09-14T08:51:53.057 回答
5

开始Scala 2.13，链接操作tap，已包含在标准库中，并且可以在我们需要打印管道的一些中间状态的任何地方以最小的侵入性使用：

import util.chaining._

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

prod(20)
// 2
// 3
// res0: IndexedSeq[Int] = Vector(6, 8, 10, 12, 14, 16, 18, 12, 15, 18)

链接操作对值（在这种情况下）tap应用副作用（在这种情况下），同时返回值（）不变：printlnaa

def tap[U](f: (A) => U): A

tap调试的时候非常方便，不用修改代码就可以使用一堆s：

def prod(m: Int) =
  for {
    a <- (2 to m.tap(println) / (2 * 3)).tap(println)
    b <- (a + 1) to (m / a.tap(println))
    c = (a * b).tap(println)
    if c < m
 } yield c
于 2019-03-17T16:08:14.353 回答
2

我通常发现这种编码风格很难遵循，因为循环和中间结果等都混在一起了。我会写一些类似的东西，而不是 for 循环

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

这也使得添加打印语句等更容易。

于 2011-09-14T08:19:39.503 回答
2

将副作用语句放在一个 for-comprehension 中（或者实际上放在任何函数的中间）似乎不是一种好的风格，除了调试，在这种情况下，你怎么称呼它并不重要（“debug " 似乎是个好名字）。

如果你真的需要，我认为你最好通过分配一个中间值来更好地分离你的关注点，例如（你原来的布局更好）：

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

变成

  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)
    }
  }
于 2011-09-14T15:49:12.357 回答