标签: flatmap

scala> List(List(1), List(2), List(3), List(4))
res18: List[List[Int]] = List(List(1), List(2), List(3), List(4))

scala> res18.flatten
res19: List[Int] = List(1, 2, 3, 4)

scala> res18.flatMap(identity)
res20: List[Int] = List(1, 2, 3, 4)

这两个功能有什么区别吗？何时使用一个而不是另一个？有任何权衡吗？

我试图创建所有可能的项目对FlatMap:

possible_children.clone().flat_map(|a| possible_children.clone().map(|b| (a,b)))

为了做到这一点,我试图克隆一个FlatMap,我在文档中看到FlatMap结构实现了一个clone方法.但似乎不可能创造FlatMap满足特征界限的东西.

这是我得到的错误:

error: no method named `clone` found for type `std::iter::FlatMap<std::ops::Range<u16>, _, [closure@src/main.rs:30:47: 33:27]>` in the current scope
  --> src/main.rs:37:66
   |
37 |         possible_children.clone().flat_map(|a| possible_children.clone().map(|b| (a,b)))
   |                                                                  ^^^^^
   |
   = note: the method `clone` exists but the following trait bounds were not satisfied: `[closure@src/main.rs:30:47: 33:27] : std::clone::Clone`

看看我看到的文档:

impl<I, U, F> Clone for FlatMap<I, U, F>
    where F: Clone, I: Clone, U: Clone + IntoIterator, U::IntoIter: …

有人可以向我解释为什么.flatMap操作员可以接受返回的函数Observable,或者array？

在官方的文档说:

FlatMap运算符通过将您指定的函数应用于源Observable发出的每个项来转换Observable,其中该函数返回一个本身发出项的Observable.

为什么它也会返回一个数组？

例如,这些都是有效的:

obs$.flatMap((data) => {
    return [];
});

obs$.flatMap((data) => {
    return new Observable<string>();
});

但这不起作用:

obs$.flatMap((data) => {
    return 1;
});

我有一个非常基本和直接的对象映射到字典.我在顶层使用和解析字典.其中一个字段是一系列其他字典.设置它们我使用的flatMap似乎是一个合适的方法,但由于里面的对象不可为空,这个方法突然返回元组(至少看起来像这样)而不是字典.

我创建了一个最小的例子,几乎可以在任何执行任何地方粘贴到新项目中,这应该提供更好的细节,然后是任何描述:

func testFlatMap() -> Data? {

    class MyObject {
        let a: String
        let b: Int
        init(a: String, b: Int) { self.a = a; self.b = b }

        func dictionary() -> [String: Any] {
            var dictionary: [String: Any] = [String: Any]()
            dictionary["a"] = a
            dictionary["b"] = b
            return dictionary
        }
    }

    let objects: [MyObject] = [
        MyObject(a: "first", b: 1),
        MyObject(a: "second", b: 2),
        MyObject(a: "third", b: 3)
    ]

    var dictionary: [String: Any] = [String: Any]()
    dictionary["objects"] = …

如何将a Set<Result>转换为Map<Item, Set<String>>或SetMultimap<Item, String>使用Java 8流或Multimaps,其中Result:

class Result {
    String name;
    Set<Item> items;
}

例如,我从:

result1:
    name: name1
    items:
        - item1
        - item2
result2:
    name: name2
    items:
        - item2
        - item3

并以:

item1:
    - name1
item2:
    - name1
    - name2
item3:
    - name2

我无法弄清楚 Scala 编译器如何弄清楚如何使用sflatMap序列Option。

如果我flatMap在一系列序列上使用 a ：

println(Seq(Seq(1), Seq()).flatMap(a => a)) // List(1)

它将连接所有嵌套序列

如果我将它与一系列Options一起使用，也会发生同样的情况：

println(Seq(Some(1), None).flatMap(a => a)) // List(1)

因此，在这种情况下，flatMap将Option视为集合。问题是为什么这样做？该flatMap定义如下：

def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That

这意味着它需要一个返回 实例的函数GenTraversableOnce，但Option不继承GenTraversableOnce。它只继承Product和Serializable，并Product继承Equals。

在这种情况下，Scala 编译器如何使用sflatMap的序列Option？

说我有这样的事情:

let values = [1,2,3,4]; 

let newValues = values.map((v) => {
  return v *v ; 
}); 

console.log(newValues); //[1,4,9,16]

挺直的.

现在,如果我想为每个对象返回多个值,该怎么办？

例如.

let values = [1,2,3,4]; 

let newValues = values.map((v) => {
  return [v *v, v*v*v, v+1] ; 
}); 

console.log(newValues); //This is what I want to get 
                        //[1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64, 5]

我可以使用reduce函数

let values = [1,2,3,4]; 

let newValues = values.map((v) => {
  return [v *v, v*v*v,v+1] ;
}).reduce((a, c) => {

  return a.concat(c); …

我正在检查.lazy高阶函数,并且得到了一些与flatMap函数相关的有趣编译错误(可能还有其他函数)

例子

 
let array = [1, 2, 3, 4, 5, 6]

array
    .flatMap {
        print("DD")
        return $0 // Cannot convert return expression of type 'Int' to return type 'String?'
    }
    .forEach {
        print("SS")
        print($0)
}

评论一下

 
array
    .flatMap {
//        print("DD")
        return $0
    }
    .forEach {
        print("SS")
        print($0)
}

一切正常......更有趣的例子

 
array
    .flatMap {
        let z = $0
        return $0  // Or return z - all is the same "Cannot convert return expression of type 'Int' to return type …

    Observable.just(1)
            .flatMap(object : Function<Int, Observable<Int>> {
                override fun apply(integer: Int): Observable<Int> {
                    return Observable.just(integer * 10)
                }
            })
            .flatMap(object : Function<Int, Observable<Int>> {
                override fun apply(integer: Int): Observable<Int> {
                    return Observable.just(integer * 20)
                }
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<Int> {
                override fun onComplete() {
                }

                override fun onSubscribe(d: Disposable) {
                }

                override fun onNext(t: Int) {
                    Log.d("result", "" + t)
                }

                override fun onError(e: Throwable) {
                    e.printStackTrace()
                }
            })

我想了解为什么使用.flatMap()withasync不会返回展平数组。

例如，对于 Typescript，这会返回一个数字数组： 我知道，对于简单的数字数组来说是没有用的，它只是更容易Promisse.all复制async

const numbers = [[1], [2], [3]];
// typed as number[]
const numbersFlatten = await Promise.all(
    numbers.flatMap((number) => number),
);

对于 Typescript，当这返回一个数字数组的数组时（刚刚添加了一个异步）：

const numbers = [[1], [2], [3]];
// typed as number[][]
const numbersFlatten = await Promise.all(
    numbers.flatMap(async (number) => number),
);