标签: for-comprehension

假设我们有一个具有协变和逆变类型参数的类：

sealed trait Pipe[-I,+O,+R]
// case subclasses

我们为此类的实例定义了单子操作：

object Pipe {
    def flatMap[I,O,Ri,R](p: Pipe[I,O,Ri], f: Ri => Pipe[I,O,R]): Pipe[I,O,R] =
        ...
}

为了能够使用for-理解，我们需要它flatMap是特征本身的方法：

sealed trait Pipe[-I,+O,+R] {
    def flatMap[I,O,Ri,R](f: Ri => Pipe[I,O,R]): Pipe[I,O,R] =
        Pipe.flatMap(this, f);
}

但是，这不会编译，失败并显示

逆变类型I出现在(R) => Pipe[I,O,R1]value类型的协变位置f。

（协变类型参数也会出现类似的错误。）

我了解该限制以及出现问题的原因。但是是否有一些解决方法，如何使用与上面相同的语义flatMap来定义特征？Pipes.flatMap也许使用一些隐式转换和/或中间构建器类？

for {
    i <- 1 to 5
  } yield Future(println(i))

脱糖：

List(1,2,3,4,5).map {i => Future(println(i))}

上面的代码以随机顺序打印数字。

现在，如果我们看到 Monad 的多个定义： a) Monad 是一个对象的包装器 b) Monad 是一种排序计算的机制

我试图回答的问题是，不应该在 List monad 上映射操作等待列表中的第一个元素被打印出来，然后才去计算第二个元素而不管 Future 是什么？

抱歉，这可能很简单，而且我把它复杂化了，但我很难找到简单的推理。答案将不胜感激:)

我想从Iterable[Try[Int]]所有有效值的列表中提取( Iterable[Int])

val test = List(
    Try(8), 
    Try(throw new RuntimeException("foo")), 
    Try(42), 
    Try(throw new RuntimeException("bar"))
)

以下是从 打印所有有效值的方法test：

for {
    n <- test
    p <- n
} println(p)

// Output
// 8
// 42

但是，当我尝试将有效值保存到列表时，我收到了一个错误：

val nums: Seq[Int] = for {
    n <- list
    p <- n    // Type mismatch. Required: IterableOnce[Int], found Try[Int]
} yield(p)
println(nums)

如何修复错误以及它为什么被提出？

有人可以详细说明当类型必须与 Scala 保持一致以进行理解时这意味着什么吗？

for {
..
..
}

如果调用都返回 Futures 那么它会好吗？只是想了解它什么时候起作用，什么时候不起作用。

我有一个带有多个 case 类的密封 trait 实现，每个 case 类都有自己的参数，其中一些具有相同类型的参数（我想提取，在这种情况下Trigger：），其中一些没有。

sealed trait Event

object MyTrait {
  final case class EventA(context: Context) extends Event

  final case class EventB(trigger: Trigger) extends Event

  final case class EventC(trigger: Trigger) extends Event

  final case class EventD(trigger: Option[Trigger] = None) extends Event

  ...

  final case class EventZ(factor: Factor) extends Event

}

逻辑流程处理如下：

event match {
 case ev @(_: Event.EventA | _: Event.EventB |
      _: Event.EventC | _: Event.EventD) =>
   val amount = for {
     count1 <- countThis …

我有以下程序:(Scala 2.9.2,Java6)

object Forcomp {
  def main(args: Array[String]): Unit = {
    val xs = List(-1, 0, 1)
    val xss = for (a <- xs; b <- xs if a != 0 && b != 0) yield (a,b)
    println(xss)
  }
}

它产生这样的输出:List((-1,-1), (-1,1), (1,-1), (1,1)) 我本来期望它只能过滤掉值,其中a和b是两个 0 -不是所有的值,其中任一 a或者b是0.

我可以通过将if子句改为此来获得我想要的行为:if (a,b) != (0,0)- 但是,我真的应该这样做吗？这是一个错误还是这种故意行为？举个例子,我对此感到惊讶.

我正在尝试构建具有唯一数字的所有N位长数的列表,但我无法弄清楚如何将其概括为一个更大问题的一部分,我需要所有的列表(1到N )数字长数字与唯一数字.

这是n = 4的手写代码:

for {
  x1 <- 1 to 9
  x2 <- 1 to 9
  x3 <- 1 to 9
  x4 <- 1 to 9
  if (x1 != x2 && x2 != x3 && x3 != x4 && x1 != x3 && x1 != x4 && x2 != x4)
  num4 = x1 + x2 * 10 + x3 * 100 + x4 * 1000
} yield num4

javaInterface返回一个Object或null.

期望:Some(String)或None.

我怎么能写得比

for {
  o <- Option(javaInterface.getValue) if o.isInstanceOf[String] 
} 
yield o.asInstanceOf[String]

简单模式匹配不是选项monad的解决方案

for {
  a <- Option(javaInterface.getValue)
  o <- Option(a.getValue) if o.isInstanceOf[String] 
}
yield o.asInstanceOf[String]

测试这个我可以看到它的工作原理:

def twoHtmlFutures = Action { request =>

  val async1 = as1.index(embed = true)(request) // Future[Result]
  val async2 = as2.index(embed = true)(request) // Future[Result]

  val async1Html = async1.flatMap(x => Pagelet.readBody(x)) // Future[Html]
  val async2Html = async2.flatMap(x => Pagelet.readBody(x)) // Future[Html]

  val source1 = Source.fromFuture(async1Html) // Source[Html, NotUsed]
  val source2 = Source.fromFuture(async2Html) // Source[Html, NotUsed]

  val merged = source1.merge(source2) // Source[Html, NotUsed]
  Ok.chunked(merged)
}

但试图将其纳入For Comprehension并不适合我.这是我试过的:

def twoHtmlFutures2 = Action.async { request =>

  val async1 = as1.index(embed = true)(request) …

在clojure中我们有一个map函数,你可以在其中提供一个函数和两个集合

(map + [1 2 ] [4 5 ]) ;;=> (5 7 )

Scala中有类似的东西吗？

我试着理解,但后来我得到了4种组合.

如果有一种方法可以理解,会更好,因为我将来必须做一些过滤/