Question

假设我有以下三个功能：

 val f1: Int => Option[String] = ???
 val f2: String => Option[Int] = ???
 val f3: Int => Option[Int]    = ???

我可以按如下方式撰写：

 val f: Int => Option[Int] = x =>
   for {
     x1 <- f1(x)
     x2 <- f2(x1)
     x3 <- f3(x2)
   } yield x3

现在假设我需要保留执行f1，f2，f3的中间结果并将它们传递给调用者：

class Result(x: Int) {
  val r1 = f1(x)
  val r2 = r1 flatMap f2
  val r3 = r2 flatMap f3
  def apply = r3 
}

val f: Int => Result = x => new Result(x)

有意义吗？您将如何改进/简化此解决方案？

Answer 1

同源列表

对于单一类型，这很简单，假设

val g1: Int => Option[Int] = x => if (x % 2 == 1) None else Some(x / 2)
val g2: Int => Option[Int] = x => Some(x * 3 + 1)
val g3: Int => Option[Int] = x => if (x >= 4) Some(x - 4) else None

您可以定义

def bind[T]: (Option[T], T => Option[T]) => Option[T] = _ flatMap _
def chain[T](x: T, fs: List[T => Option[T]]) = fs.scanLeft(Some(x): Option[T])(bind)

现在

chain(4, g1 :: g2 :: g3 :: Nil)

将是

列表（一些（4），一些（2），一些（7），一些（3））

保留所有中间值。

异类列表

但如果涉及多种类型，我们可以做到吗？

幸运的是，有shapeless库用于名为Heterogenous List的特殊结构，它可以处理类似列表的多类型值序列。

假设我们有

import scala.util.Try

val f1: Int => Option[String] = x => Some(x.toString)
val f2: String => Option[Int] = x => Try(x.toInt).toOption
val f3: Int => Option[Int] = x => if (x % 2 == 1) None else Some(x / 2)

让我们将异质类似物定义为以前的函数：

import shapeless._
import ops.hlist.LeftScanner._
import shapeless.ops.hlist._

object hBind extends Poly2 {
  implicit def bind[T, G] = at[T => Option[G], Option[T]]((f, o) => o flatMap f)
}
def hChain[Z, L <: HList](z: Z, fs: L)
                         (implicit lScan: LeftScanner[L, Option[Z], hBind.type]) =
  lScan(fs, Some(z))

现在

hChain(4, f1 :: f2 :: f3 :: HNil)

评估到

一些（4）::一些（“4”）::一些（4）::一些（2）:: HNil

类转换器

现在，如果您要求将结果保存在某些类

中

case class Result(init: Option[Int], 
                  x1: Option[String], 
                  x2: Option[Int], 
                  x3: Option[Int])

您可以轻松使用Generic representation

确保自己

Generic[Result].from(hChain(4, f1 :: f2 :: f3 :: HNil)) == 
  Result(Some(4),Some("4"),Some(4),Some(2))

保持功能组成的中间结果

1 个答案:

同源列表

异类列表

类转换器