How can I write the transformation in a cleaner way

Question

I have a method which takes a list of object (Widget) -- which contains some properties (header) and nested list(component). I want to flatten the list into a single list and have the below code for same:

@SuppressLint("CheckResult")
    fun flatten(fatList: Single<List<Widget>>) {
        val flatList: MutableList<IUiData> = mutableListOf()

        fatList.map {
            Observable.fromIterable(it).map { widget ->
                if (widget.header.isNotEmpty()) {
                    flatList.add(ProductHeaderUi(widget.header))
                }
                widget.componentList.map { component ->
                    when (component.type) {
                        TILE_TEXT -> {
                            flatList.add(HeaderUi(component))
                        }
                        TILE_IMAGE -> {
                            flatList.add(ImageTileUi(component))
                        }
                        TILE_FOOTER -> {
                            flatList.add(FooterUi(component))
                        }
                        UNKNOWN -> {
                            //Do Nothing 
                        }
                    }
                }
            }
        }
    }

I intend to return a Single of List: Single<MutableList<IUiData>> from this method, this purpose can be served right now, but I am looking for a cleaner way

Answer 1

You're using both Rx's Observable map and Kotlin's Iterable map in an unintended way. They are for converting one type to another, not for iterating something.

You've also nested an unnecessary Observable iterable inside the outer-most map function.

You only need to map the output of the Single. Inside the map function, you iterate (not map) the original List to pull out the data you need for the MutableList.

I'm an Rx novice and didn't check this, so sorry about any syntax errors.

fun flatten(fatList: Single<List<Widget>>): Single<MutableList<IUData>> = fatList.map { widgetList ->
    val flatList: MutableList<IUiData> = mutableListOf()
    for (widget in widgetList) {
        if (widget.header.isNotEmpty()) {
            flatList.add(ProductHeaderUi(widget.header))
        }
        for (component in widget.componentList) { 
            when (component.type) {
                TILE_TEXT -> flatList.add(HeaderUi(component))
                TILE_IMAGE -> flatList.add(ImageTileUi(component))
                TILE_FOOTER -> flatList.add(FooterUi(component))
                // Else do nothing
            }
        }
    }
    flatList
}

But in keeping with typical Rx chaining syntax, I would make it an extension function, so I'd have to first line like this. Then you can put it right in the middle of an Rx call chain:

fun Single<List<Widget>>.flatten(): Single<MutableList<IUData>> = map { widgetList ->

You can also do this in a more concise, functional, but less efficient way by using Kotlin's flatMap:

fun Single<List<Widget>>.flatten(): Single<MutableList<IUData>> = map {
    it.flatMap { widget ->
        listOfNotNull(widget.header.takeIf(Header::isNotEmpty)?.let(::ProductHeaderUi))
        +
        widget.componentList.mapNotNull { component ->            
           when (component.type) {
                TILE_TEXT -> HeaderUi(component)
                TILE_IMAGE -> ImageTileUi(component)
                TILE_FOOTER -> FooterUi(component)
                else -> null
            }
        }.toMutableList()
}

...where Header is whatever type widget.header uses.