小编Pet*_*ens的帖子

我已经阅读了有关的文档map,flatMap并且我理解它flatMap用于接受Future参数并返回另一个参数的操作Future.我不完全理解的是为什么我想这样做.举个例子:

1. 用户点击我的网络服务要求"做东西"
2. 我下载了一个文件(很慢)
3. 我处理文件(CPU密集型)
4. 渲染结果

我知道我想使用未来下载文件,但我有两个选项重新处理它:

val downloadFuture = Future { downloadFile }
val processFuture = downloadFuture map { processFile }
processFuture onSuccess { case r => renderResult(r) }

要么

val downloadFuture = Future { // download the file }
val processFuture = downloadFuture flatMap { Future { processFile } }
processFuture onSuccess { case r => renderResult(r) }

通过添加调试语句(Thread.currentThread().getId),我看到在两种情况下都下载,process并render发生在同一个线程中(使用ExecutionContext.Implicits.global).

我会flatMap …

我看到一些Scala代码写成:

 def next(): Array[String] = someVariable.next() :+ iterator.key

哪里someVariable有一个方法next()来获取下一行,迭代器是类型Iterator[String].

:+这里的意思是什么？

我想计算一个简单的数字,如果数字不是整数,我想把它整理一下.

因此,如果计算后得到1.2我想将其更改为2,如果数字为3.7我想将其更改为4,依此类推.

我有这条线,我正在计算一个数字:

val num1 = (vatReclaimed/vatPaid) * 100

此外,Scala中的计算语法不正确,如果有人也能纠正这个简单的行,我将不胜感激.(vatReclaimed/ vatPaid是字符串)

object Main extends App {
  val p1 = Promise[Option[String]]()
  val p2 = Promise[Option[String]]()
  val f1 = p1.future
  val f2 = p2.future

  val res = (for{
    file1Opt <- f1
    file2Opt <- f2
    file1 <- file1Opt
    file2 <- file2Opt
  } yield {
    combineFiles(file1, file2)
  }).fallbackTo(Future.successful("Files not found"))

  Thread.sleep(2000)
  println("XXXXXXXXXXXXXXXXXXX")

  p1.success(Some("file one"))
  p2.success(Some("file two"))

  val finalData = res.map(s =>
    s + " " + "add more data to the file"
  ) 

  finalData.map(println(_))

  def combineFiles(f1: String, f2: String): String = {
    f1 + " …

Haskell中的Free实现是:

data Free f a =
Pure a
| Free (f (Free f a))

然而,Scalaz中的实现是:

sealed abstract class Free[S[_], A]

private case class Return[S[_], A](a: A) extends Free[S, A]
private case class Suspend[S[_], A](a: S[A]) extends Free[S, A]
private case class Gosub[S[_], B, C](a: Free[S, C], f: C => Free[S, B]) extends Free[S, B]

为什么scalaz实现不像Haskell,如:

sealed trait Free[F[_],A]
case class Return[F[_],A](a: A) extends Free[F,A]
case class GoSub[F[_],A](s: F[Free[F,A]]) extends Free[F,A]

这两种实现都是同构的吗？

我想将一个字符串和一个模型(对象)发送给另一个动作.

var hSM = new HotelSearchModel();
hSM.CityID = CityID;
hSM.StartAt = StartAt;
hSM.EndAt = EndAt;
hSM.AdultCount = AdultCount;
hSM.ChildCount = ChildCount;

return RedirectToAction("Search", new { culture = culture, hotelSearchModel = hSM });

当我使用new关键字时它发送null对象,虽然我设置了对象hSm属性.

这是我的Search行动:

public ActionResult Search(string culture, HotelSearchModel hotelSearchModel)
{ 
    // ...
}

我正在阅读这段代码很长一段时间.我把它键入REPL,它也可以.

但我不知道这里发生了什么.为什么以及如何工作!

import shapeless._

case class Size[L <: HList](get : Int)
object Size {
    implicit val hnilSize = Size[HNil](0)
    implicit def hconsSize[H, T <: HList](implicit tailSize: Size[T]) = 
        Size[H :: T](1 + tailSize.get)
    def apply[L <: HList](l : L)(implicit size: Size[L]) : Int = size.get
}

Size(1 :: "Foo" :: true :: HNil)

有人可以一步一步地解释这一点,并帮助我理解这里发生了什么.

给出以下AST Success和Failure:

sealed trait Success
case object FooGood extends Success
case object BarGood extends Success

sealed trait Failure
case object FooBad extends Failure
case object BarBad extends Failure

方法签名:

def go[A <: Failure, B <: Success](x: Int): Either[A, B] = ???

但是,我想约束Left和Right类型特定于Foo或Bar.

但是下面的代码编译(违背我的意愿):

scala> go[FooBad.type, BarGood.type](5)
scala.NotImplementedError: an implementation is missing

如何在编译时实现此约束？

如果我使用xxx.flatMap(_.split(" "))，它会拆分数组然后展平还是会展平然后拆分？

假设我有一个“广泛的”密封类层次结构：

sealed trait Alphabet
case class A(word: String) extends Alphabet
...
case class Z(word: String) extends Alphabet

并说我为层次结构中的每个子类定义了一个类型类实例：

trait SwearWordFinder[T <: Alphabet] {
  def isSwearWord(x: T): Boolean
}

val swearWordFinderA = new SwearWordFinder[A] { ... }
...
val swearWordFinderZ = new SwearWordFinder[Z] { ... }

有没有一种方法可以为Alphabet特征本身定义类型类实例，而不必通过模式匹配来实现（如下所示）？

def isSwearWord(x: Alphabet): Boolean = x match {
  case a: A => swearWordFinderA.isSwearWord(a)
  ...
  case z: Z => swearWordFinderZ.isSwearWord(z)
}