标签: for-comprehension

我发现Scala总是对任何东西都有"自然的解释".总是像"哦,但这只是一个函数被调用此函数和该对象与此参数".从某种意义上说,我们从其他语言中知道它并不是真正的编译器魔法.

我的问题是在以下代码中使用的< -运算符:

for(i <- 0 to 10) println(i)

在这个例子中,我可以看到它被重写为:

0.to(10).foreach((i:Int)=>println(i))

但这并没有解释我如何进入foreach函数内的匿名函数.在你写i的时候,它不是一个对象,也不是一个声明的变量.那是什么呢,它是如何被带到foreach的内部的呢？

我的猜测是,我终于发现了一些实际上是编译魔术的东西

谢谢你的时间.

为了澄清,我的问题是:如何做的< -在代码的第一线操作人员的工作,因为我不上它可作为函数调用的对象.

在下面的示例中,我得到了例外 java.util.NoSuchElementException: Future.filter predicate is not satisfied

我想Future( Test2 )在检查if( i == 2 )失败时获得结果.我如何处理过滤器/如果处理组成期货的理解？

下面是一个在Scala REPL中工作的简化示例.

码:

import scala.concurrent.Future
import scala.util.{ Try, Success, Failure }
import scala.concurrent.ExecutionContext.Implicits.global

val f1 = Future( 1 )
val f2 = for {
  i <- f1
  if( i == 2 )
} yield "Test1"
f2.recover{ case _ => "Test2" }
f2.value

val x = for(i <- 1 to 3) yield i
x match {
    case 1 :: rest => ... // compile error
}

构造函数无法实例化为期望的类型; found:collection.immutable.::: [B] required:scala.collection.immutable.IndexedSeq [Int]

当匹配收到IndexedSeq而不是LinearSeq时,这与MatchError的问题相同.

问题是,怎么做对了？.toList到处添加似乎不对.并创建一个自己的提取器来处理每一个Seq(如另一个问题的答案所述)如果每个人都这样做会导致一团糟......

我想问题是,为什么我不能影响序列理解的返回类型,或者:为什么不是Seq标准库的这种通用提取器部分？

我问的是一个让我最近困惑的基本问题.我想编写一个Scala For表达式来执行以下操作:

for (i <- expr1) {
  if (i.method) {
    for (j <- i) {
      if (j.method) {
        doSomething()
      } else {
        doSomethingElseA()
      }
    }
  } else {
    doSomethingElseB()
  }
}

问题是,在多个生成器For表达式中,我不知道我可以在哪里放置表达式主体.

for {i <- expr1
  if(i.method) // where can I write the else logic ?
  j <- i 
  if (j.method)
} doSomething()

如何在Scala Style中重写代码？

如何将此地图/ flatMap转换为for comprehension,请解释它是如何工作的,谢谢.

    def compute2(maybeFoo: Option[Foo]): Option[Int] =
      maybeFoo.flatMap { foo =>
      foo.bar.flatMap { bar =>
          bar.baz.map { baz =>
          baz.compute
      }
    }
  }  

在他的Coursera课程的倒数第二次讲座中,奥德斯基教授提供了以下for理解作为可爱案例研究的最后一步:

def solutions(target: Int): Stream[Path] =
  for {
    pathSet <- pathSets
    path <- pathSet
    if path.endState contains target
  } yield path

在之前的一次演讲中,他在for理解和SQL 之间进行了一些类比.

我正在寻找的yield只是那些path拥有一个DISTINCT endState.

有没有办法从相同理解的过滤条款中回溯到已经产生的项目？

另一种方法可能是转换pathSets到Map从endState到path了之前for的语句,然后将其转换回一个Stream返回之前.但是,这似乎失去了使用a的懒惰计算好处Stream.

同一个案例研究的早期方法实现了类似的目标,但它已经是一个递归函数,而这个函数(似乎)不需要递归.

看起来我可以使用mutable Set来跟踪endState得到的s,但是感觉不满意,因为到目前为止该课程已成功避免使用可变性.

假设我有两个选项,如果两个都是Some,则执行一个代码路径,如果是note,则执行另一个.我想做点什么

for (x <- xMaybe; y <- yMaybe) {
  // do something
}
else {
  // either x or y were None, handle this
}

在if语句或模式匹配之外(如果我有两个以上的选项可能无法扩展),有没有更好的方法来处理它？

给定一个数字与多个字符相关联的地图

scala> val conversion = Map("0" -> List("A", "B"), "1" -> List("C", "D"))
conversion: scala.collection.immutable.Map[java.lang.String,List[java.lang.String]] =
  Map(0 -> List(A, B), 1 -> List(C, D))

我想基于一系列数字生成所有可能的字符序列.例子:

"00" -> List("AA", "AB", "BA", "BB")
"01" -> List("AC", "AD", "BC", "BD")

我可以用这些来理解

scala> val number = "011"
number: java.lang.String = 011

为每个索引创建一系列可能的字符

scala> val values = number map { case c => conversion(c.toString) }
values: scala.collection.immutable.IndexedSeq[List[java.lang.String]] =
  Vector(List(A, B), List(C, D), List(C, D))

生成所有可能的字符序列

scala> for {
     | a <- values(0)
     | b <- …

我有一个应用程序,可以对不同的后端系统进行大量调用,并希望使用for-comprehensions来简化后端系统的流程.

我希望结合使用EitherT(scalaz)和Future(scala 2.10),这样我就可以捕获第一个潜在错误(其未来或后端系统问题),并向最终用户返回相应的消息.我已经快速查看了scalaz验证,但是建议捕获第一个错误而不是所有错误都是使用EitherT.

我首先在REPL中尝试一个简单的例子,但是我收到了以下错误

错误:找不到参数F的隐含值:scalaz.Functor [scala.concurrent.Future]

import scala.concurrent._
import scalaz._
import Scalaz._
import ExecutionContext.Implicits.global

type EitherFuture[+A] = EitherT[Future, String, A]

def method1Success : EitherFuture[Int] = {
  println("method 1 success")
  EitherT {
    Future {
      1.right
    }
  }
}

def method2Failure : EitherFuture[Int] = {
  println("method 2 failure")
  EitherT {
    Future {
      "fail".left
    }
  }
}

val m1 = method1Success

// problem
m1.isRight

// problem
def methodChain1 = {
  for {
    a <- method1Success
    b <- method2Failure
  } yield b
}

我仍然是scala和scalaz的新手,所以任何指针都会很棒. …

我可以"屈服"成地图吗？

我试过了

val rndTrans = for (s1 <- 0 to nStates;
                    s2 <- 0 to nStates
                        if rnd.nextDouble() < trans_probability)
                            yield (s1 -> s2);

(而,不是->)但我得到了错误

TestCaseGenerator.scala:42: error: type mismatch;
 found   : Seq.Projection[(Int, Int)]
 required: Map[State,State]
    new LTS(rndTrans, rndLabeling)

我明白为什么,但我看不出如何解决这个问题: - /