标签: flatmap

有没有办法将Future类型的对象[未来[T1],未来[T2]]]转换为类型为[Future [T1],Future [T2]]的对象？

也许像flatMap这样适用于Either ....

我正在尝试使这个代码工作(我有类似的代码实现包裹的行动链,但它不涉及未来.它工作,更简单).下面的代码是基于此,通过必要的修改使其适用于涉及期货的情况.

case class WebServResp(msg: String)
case class WebStatus(code: Int)
type InnerActionOutType = Either[Future[Option[WebServResp]], Future[WebStatus]]
type InnerActionSig = Future[Option[WebServResp]] => Either[Future[Option[WebServResp]], Future[WebStatus]]

val chainOfActions: InnerActionSig = Seq(
  {prevRespOptFut => 
    println("in action 1: " + prevRespOptFut)
    //dont care about prev result
    Left(Future.successful(Some(WebServResp("result from 1"))))
  },
  {prevRespOptFut => 
    println("in action 2: " + prevFutopt)
    prevRespOptFut.map {prevRespOpt =>
      //i know prevResp contains instance of WebServResp. so i skip the opt-matching
      val prevWebServResp = prevRespOpt.get
      Left(Some(prevWebServResp.msg + " & " …

我无疑是Scala的新手,我在许多Scala示例中遇到的语法糖问题.它通常会产生一个非常简洁的陈述,但老实说到目前为止(对我而言)有点难以理解.

因此,我希望将Option类(安全解除引用)的典型用法作为开始理解的好地方,例如,在我看到的特定示例中使用下划线.

我发现了一篇非常好的文章,展示了使用Option来避免null的情况.

https://medium.com/@sinisalouc/demystifying-the-monad-in-scala-cc716bb6f534#.fhrljf7nl

他描述了一个用途:

trait User {
  val child: Option[User]
}

顺便说一句,您也可以将这些函数编写为就地lambda函数,而不是先验地定义它们.然后代码变为:

val result = UserService.loadUser("mike")
  .flatMap(user => user.child)
  .flatMap(user => user.child)

那看起来很棒!也许不像人们在groovy中那样简洁,但也不错.

所以我想我会尝试将它应用到我想要解决的案例中.

我有一种类型Person,其中a的存在Person是可选的,但如果我们有一个人,他的属性是有保证的.出于这个原因,没有使用的Option的内型Person类型本身.

的Person具有PID它的类型的Id.该Id类型包括两种String类型; Id-Type和Id-Value.

我使用Scala控制台测试以下内容:

class Id(val idCode : String, val idVal : String)

class Person(val pid : Id, val name : String)

val anId: Id = new Id("Passport_number", "12345")

val person: Person = new Person(anId, "Sean")

val operson : …

我有这个prbolem,我有一个RDD[(String,String, List[String]),我想"flatmap"它获得一个RDD[(String,String, String)]:

例如:

val x :RDD[(String,String,  List[String]) = 
RDD[(a,b, list[ "ra", "re", "ri"])]

我想得到:

val result: RDD[(String,String,String)] = 
RDD[(a, b, ra),(a, b, re),(a, b, ri)])]

我有这段代码,我想返回一个postCodes列表:

List<String> postcodes = new ArrayList<>();
List<Entry> entries = x.getEntry(); //getEntry() returns a list of Entry class
for (Entry entry : entries) {
    if (entry != null) {
       Properties properties = entry.getContent().getProperties();
       postcodes.addAll(Arrays.asList(properties.getPostcodes().split(",")));
   }
} 
return postcodes;

这是我尝试使用stream()方法和以下链式方法:

...some other block of code
List<Entry> entries = x.getEntry.stream()
    .filter(entry -> recordEntry != null)
    .flatMap(entry -> {
        Properties properties = recordEntry.getContent().getProperties();
        postCodes.addAll(Arrays.asList(properties.getPostcodes().split(",")));
});

我想要展平一个看起来像这样的数组:

[{
    "id": 0,
    "text": "item 0"
}, {
    "id": 1,
    "items": [{
        "id": 2,
        "text": "item 2"
    }, {
        "id": 3,
        "items": [{
            "id": 4,
            "text": "item 4"
        }]
    }]
}]

进入这个

[{
    "id": 0,
    "text": "item 0"
}, {
    "id": 2,
    "text": "item 2"
}, {
    "id": 4,
    "text": "item 4"
}]

基本上保留所有没有"items"属性的元素,如果它们有一个,则以递归方式遍历所有"items"数组.

我确实可以写一个递归函数,但我正在寻找一个漂亮的lodash或下划线方法来解决这个问题.

我正在和Swift玩耍，但遇到了一些麻烦flatMap。我已经看到了这个 StackOverflow问题，该问题描述了如何使用来展平数组的数组flatMap，但是当我在操场上重现相同的代码时，它并不会展平该数组。如果有人可以提供一些有关此处发生的情况的见解，我将不胜感激。

这是代码和结果的屏幕截图：

我很难理解Scala中使用for-compression的机制。例如，如果我有

val x = for {
  i <- Option(1)
  j <- Option(2)
  k <- Option(3)
} yield (i,j,k)

x是x: Option[(Int, Int, Int)] = Some((1,2,3))。但是，例如，如果组件中的至少一个为“无”，

val x = for {
  i <- Option(1)
  j <- Option(2)
  k <- None
} yield (i,j,k)

然后x是的x: Option[(Int, Int, Nothing)] = None，而我实际上希望看到这样的东西：x: Option[(Int, Int, Nothing)] = Some((1,2,None))。

我已经检查了从Scala的官方文档常见问题在那里特别指出for-comprehension的组合flatmap和map。但我还是有难度的理解是，x是None。

我想我错过了一些重要的概念flatmap和map区别。

在Scala中，对于包含要分解的数组的case类，是否可以更有效地使用平面地图？

这是一个有效的代码，但看起来不正确：

object stuff {
    def main(args: Array[String]): Unit = {
        case class Stuff(name: String, stuff: Seq[String])
        case class FlatStuff(name: String, stuff: String)

        val someStuff = Array(Stuff("a", Seq("1", "2", "3")), Stuff("b", Seq("4", "5")))

        val stuffs = someStuff.flatMap(item => {
            val flatten = new Array[FlatStuff](item.stuff.length)
            for (i <- 0 until item.stuff.length) {
                flatten(i) = FlatStuff(item.name, item.stuff(i))
            }
            flatten
        })

        stuffs.foreach(stuff => println(stuff))
    }
}

flatMap所以我一直在阅读一些关于 scala 中的 Monad 的文章，以及与其函数和理解相关的所有语法for。直观上，我理解为什么 Monad 需要使用函数map的一部分flatMap，就像通常当我map在零个、一个或多个元素的容器上使用函数时，它返回相同的容器，但传入的函数应用于所有元素容器。类似地，Monad 是零个、一个或多个元素的容器。

flatten然而，这部分的目的是什么flatMap？我无法理解其背后的直觉。对我来说，这似乎是额外的样板，需要传递所有函数来围绕其返回值创建一个容器/flatMap单子，只是让该容器立即被. 我想不出使用 的单个示例不能通过简单地替换为 来简化。例如：flattenflatMapflatMapmap

var monad = Option(5)
var monad2 = None

def flatAdder(i:Int) = Option(i + 1)
def adder(i:Int) = i + 1

// What I see in all the examples
monad.flatMap(flatAdder)
// Option[Int] = Some(6)
monad.flatMap(flatAdder).flatMap(flatAdder)
// Option[Int] = Some(7)
monad2.flatMap(flatAdder)
// Option[Int] = None
monad2.flatMap(flatAdder).flatMap(flatAdder)
// Option[Int] = None

// Isn't …

val l = List(1,2,3)
val f = l flatMap (_ + 1)

我在 Scala 中运行上述代码段，但出现以下错误。

<console>:12: error: type mismatch;
 found   : Int(1)
 required: String
       val f = l flatMap (_ + 1)

是什么flatMap做的是，它进行地图功能，我们提供（在这种情况下- >：_ + 1），然后遍历map函数的结果。如果迭代器在地图输出上不可用，则会引发此错误。

我的理解正确吗？