Scala不是为了理解而编译的

我正在尝试运行以下代码：

def split(input: Int): List[Int] = {
  val inputAsString = input.toString
  val inputAsStringList = inputAsString.split("").toList
  inputAsStringList.map(_.toInt).reverse
}

split(3122)

def increment(list: List[Int]): List[Int] = {
  def loop(multiplier: Int, result: List[Int], list: List[Int]): List[Int] = list match {
    case x :: xs =>
      val newList = (x * multiplier) :: result
      loop(multiplier * 10, newList, xs)
    case Nil => result
  }

  loop(1, List(), list)
}

val result: List[Int] = for {
  splited <- split(3122)
  incremented <- increment(splited)
} yield incremented

def拆分（输入：Int）：列表[Int]={
val inputAsString=input.toString
val inputAsString=inputAsString.split（“”）.toList
inputAsStringList.map（u.toInt）.reverse
}
斯普利特（3122）
def增量（列表：列表[Int]）：列表[Int]={
def循环（乘数：Int，结果：List[Int]，List:List[Int]）：List[Int]=列表匹配{
案例x:：xs=>
val newList=（x*乘数）：：结果
循环（乘数*10，新列表，xs）
案例Nil=>结果
}
循环（1，List（），List）
}
val结果：列表[Int]=用于{
splited您的
增量
函数采用
列表[Int]
，但是
splited
是一个
Int
函数，在理解过程中。这是因为在
splited行中，您的
增量
函数采用
列表[Int]，但是<代码>分裂是一个<代码> int /代码>，在for for理解中。这是因为在行<代码>分裂中，请考虑下面的例子来理解理解：

//For comprehension:
for {
    a <- aMonad
    b <- bMonad
    //....some more....
    z <- zMonad
} yield {
    ???
}

//means:
aMonad.flatMap { a =>
    bMonad.flatMap { b =>
        //{{{...some more
        //notice here it is .map instead of flatMap
        zMonad.map { z =>
            //something
            ???
        }
        //}}}
    }
}

//为了理解：
为了{
A.
//某物
???
}
//}}}
}
}

单子阿莫纳德，波莫纳德。。zMonad应该是类似类型的单子，例如，列表[u]、未来[u]等，用于理解

这意味着，类型为List[Int]的aMonad和类型为Future[Int]的bMonad不能像上述代码那样用于理解，而如果它们是List[Int]和List[String]类型，则没有问题

进一步阅读：


 
 < P>请考虑下面的例子来理解理解是什么：

//For comprehension:
for {
    a <- aMonad
    b <- bMonad
    //....some more....
    z <- zMonad
} yield {
    ???
}

//means:
aMonad.flatMap { a =>
    bMonad.flatMap { b =>
        //{{{...some more
        //notice here it is .map instead of flatMap
        zMonad.map { z =>
            //something
            ???
        }
        //}}}
    }
}

//为了理解：
为了{
A.
//某物
???
}
//}}}
}
}

单子阿莫纳德，波莫纳德。。zMonad应该是类似类型的单子，例如，列表[u]、未来[u]等，用于理解

这意味着，类型为List[Int]的aMonad和类型为Future[Int]的bMonad不能像上述代码那样用于理解，而如果它们是List[Int]和List[String]类型，则没有问题

进一步阅读：


顺便说一句，你的
循环（）不循环。@jwvh我已经更改了递增函数。现在它正确循环了。顺便说一句，你的
loop（）
没有循环。@jwvh我已经更改了增量函数。现在它正确地循环了。
理解的
产生其唯一生成器的结果是多余的，相当于一个基本赋值：
val result=increment（splited）
。问题是为什么OP的代码不会编译——这不是最好的解决方案，但它是一个解决方案。我同意把for CONTRUMENT分成两个val语句要好得多。那么我应该把for CONTRUMENT分成两个语句吗？在我看来，没有一种方法可以在一个声明中做到这一点。您可以编写
valresult:List[Int]=increment（split（3122））
（outputs
List（3000，100，20，2）
），但尽管这样做有效，但我个人更喜欢将我的东西拆分到多行上，至少在重构之前，因为这有助于我在出现问题时进行调试。这取决于你。
理解产生唯一生成器结果的
是多余的，相当于一个基本赋值：
val result=increment（splited）
。问题是为什么OP的代码不会编译——这不是最好的解决方案，但它是一个解决方案。我同意把for CONTRUMENT分成两个val语句要好得多。那么我应该把for CONTRUMENT分成两个语句吗？在我看来，没有一种方法可以在一个声明中做到这一点。您可以编写
valresult:List[Int]=increment（split（3122））
（outputs
List（3000，100，20，2）
），但尽管这样做有效，但我个人更喜欢将我的东西拆分到多行上，至少在重构之前，因为这有助于我在出现问题时进行调试。这取决于你。