Hey guys, Can we improve this piece of code ?

fun getConsultationCoverageList(): List<ContentWithTitle> {
    val list = mutableListOf<ContentWithTitle>()
    val consultation = getConsultationItem()
    consultation?.consultationCategories?.forEachIndexed { _, consultationCategory ->
        val paragraphs = mutableListOf<Paragraph>()
        consultationCategory.consultationTopics?.forEachIndexed { _, consultationTopics ->
            paragraphs.add(Paragraph(type = LIST_ITEM.type, text = consultationTopics.title))
        }

        list.add(ContentWithTitle(title = consultationCategory.title, content = Paragraphs(paragraphs), description = consultationCategory.description))
    }
    return list
}

forEachIndexed { _, x -> ... }

is pointless because it discards the index. You may as well use

forEach

in the first place.

no need for the mutable list either, just

getConsultationItem()?.consultationCategories?.map { category ->
    val paragraphs = category.consultationTopics?.map {
        Paragraph(...)
    }.orEmpty()
    ContentWithTitle(...)
}.orEmpty()

@Joffrey nice code. Thanks for helping me.

Using

map

is just a more standard way of doing the same thing. The time complexity is unchanged. It is just an abstraction to better convey your intent

okkk now, I got it thank you so much guys.

Note that the final code might look a bit complex. To make it look better you can extract extension functions. For instance, instead of:

val paragraphs = consultationCategory.consultationTopics.orEmpty().map {
    Paragraph(type = LIST_ITEM.type, text = it.title)
}

You could have:

val paragraphs = consultationCategory.consultationTopics.orEmpty().map { it.toParagraph() }

If you define an extension function:

private fun ConsultationTopic.toParagraph() = Paragraph(type = LIST_ITEM.type, text = title)

This usually reads better, again because of the higher level of abstraction, hiding the details

Great stuff. You are amazing. Thanks it look better in my code now.

have you read the documentation https://kotlinlang.org/docs/collections-overview.html or worked through other resources such as https://kotlinlang.org/docs/koans.html or any other resources? you have many questions that are already covered

The end game could look like this:

fun getConsultationCoverageList(): List<ContentWithTitle> =
    getConsultationItem()?.consultationCategories.orEmpty().map { it.toContentWithTitle() }

private fun ConsultationCategory.toContentWithTitle(): ContentWithTitle =
    ContentWithTitle(title = title, content = paragraphs, description = description)

private val ConsultationCategory.paragraphs
    get() = Paragraphs(consultationTopics.orEmpty().map { it.toParagraph() })

private fun ConsultationTopic.toParagraph() = Paragraph(type = LIST_ITEM.type, text = title)

@ephemient I'll check that resources. thanks

Another point that we haven't covered so far is the nullability of your lists in the first place. If you don't care about the distinction between

null

or empty list for your use case (which is the case in this piece of code), you should probably make them non-nullable in the first place in your classes. This will get rid of those

.orEmpty()

everywhere. That is, unless those classes are defined in Java and you have no choice but to deal with null

I think I don't need

.orEmpty()

In your initial code you had safe-call operators (

?.

) so I assumed your lists were nullable, my bad

no problem.