Could you show an example? In general blockingFirs...

# rx

[gildor]

Could you show an example?
In general blockingFirst sounds bad and flatmap is standard way to do that

[rakeeb]

so the getParent() is the way to go?

https://kotlinlang.slack.com/files/U5GA4KDL6/FA23RH2KV/Idiomatic_nested_mapping_for_Observable_s_.kt

[rakeeb]

Idiomatic_nested_mapping_for_Observable_s_.kt

Idiomatic_nested_mapping_for_Observable_s_.kt

[gildor]

Ehhmm, no, I think your solution is completely wrong and work only by change and only for single thread. Maybe you should check some basic tutorials about RxJava and operatos

[gildor]

First, try to fix your example in general, forr exampl you try to change val

[rakeeb]

the example was something i just wrote right away. I wanted to know how nested Observable dependencies were handled.

[rakeeb]

on our production app, a similar class was created for our domain layer, which combines different data entities into one class.

[gildor]

To nest observables use flatMap

[gildor]

As I understand your example you need something like this:

val parents: Single<List<Parent>> = getParents()
return parents.toObservable().flatMapIterable { it }
    .flatMap { parent ->
        Observable.zip(
                getFirst(parent),
                getSecond(parent),
                BiFunction<List<First>, List<Second>, Parent> { f, s ->
                    parent.apply {
                        first = f
                        second = s
                    }
                })
    }
    .toList()

[rakeeb]

damn! that’s such an elegant solution! thanks 🙂

[gildor]

So you just flatMap each item of parent on each item your request both child and zip them together with parent

[gildor]

General rule: do not use side effects operators (like doOnNext) for such cases, use only operators that modify data stream

[gildor]

Also general rule, try to avoid mutable objects like in this case with parent

[gildor]

use two different objects instead: parent without children and create new Parent (maybe even different class) with children

[gildor]

something like that:

val parentIds: Single<List<Int>> = getParentIds()
return parentIds.toObservable().flatMapIterable { it }
    .flatMap { parentId ->
        Observable.zip(
                getFirst(parentId),
                getSecond(parentId),
                BiFunction<List<First>, List<Second>, Parent> { f, s ->
                    Parent(parentId, f, s)
                })
    }
    .toList()
}

[rakeeb]

yes, definitely makes lot of sense. my purpose with the parent was to use it as a composition class.

really learned a lot, thanks for taking out the time to explain 🙂

[gildor]

yes, it’s fine to compose, but avoid mutable classes, just create copy if you don’t want to mess up multithreading