Splitting a list in Kotlin

Question

I want to split a list (as if splitting a string by a delimiter), ideally in a functional style, and was surprised how hard it seems to be. Or maybe my code is just unnecessarily complicated?

fun <ElemType : Comparable<ElemType>> Iterable<ElemType>.split(delim: ElemType): 
List<List<ElemType>> {
 return this.fold(emptyList<List<ElemType>>()) { 
 acc: List<List<ElemType>>, elem: ElemType ->
 if (elem == delim) 
 acc + listOf(emptyList<ElemType>())
 else if (acc.isEmpty()) 
 listOf<List<ElemType>>(listOf<ElemType>(elem)) 
 else 
 acc.take(acc.size - 1) + listOf(acc.last() + elem)
 }
}
fun main() {
 val l = listOf("1", "", "2", "3", "", "", "4")
 println(l.split(""))
 
 val l2 = listOf(1, 0, 2, 3, 0, 0, 4)
 println(l2.split(0))
}

The result for both cases is [[1], [2, 3], [], [4]].

Kotlin Playground

• Simon Forsberg: Out of curiosity, why "ideally in a functionally style"?
• Felix Dombek: Because I can write procedural code in a lot of languages, but am learning functional idioms in Kotlin.
• Simon Forsberg: Well you chose a tough assignment to learn functional idioms with xD But possibly if you would have handled it list-by-list by searching for the delimiters instead of element-by-element it might have been easier.

Answer 1

It's complicated because you are making it unnecessarily complicated.

I wouldn't use .fold to accomplish this.

Think about how many list operations this line does: acc.take(acc.size - 1) + listOf(acc.last() + elem)

• acc.take(acc.size - 1) copies the current list of sublists except the last.
• listOf(acc.last() + elem) (I believe this could be just acc.last() + elem?) creates a new list with one element appended to the last list.

We know that once we've seen a delimiter, we don't need to touch any previous lists, we can just continue looking at what's ahead of us.

This makes it a perfect choice for a sequence builder.

fun <ElemType> Iterable<ElemType>.split(delim: ElemType): List<List<ElemType>> {
 return sequence {
 val currentList = mutableListOf<ElemType>()
 for (elem in this@split) {
 if (elem == delim) {
 yield(currentList.toList())
 currentList.clear()
 } else {
 currentList.add(elem)
 }
 }
 yield(currentList.toList())
 }.toList()
}

Other notes: Your function requires ElemType to extend Comparable<ElemType>. I do not see any reason for this. You can remove that restriction.

• Felix Dombek: Thanks, I thought I needed Comparable for elem == delim, but I now realize that equals is defined for all objects.
• Felix Dombek: And maybe I don't even need the toList() at the end ... this could even be lazy.
• Simon Forsberg: @FelixDombek Yup, if possible I would recommend using it as a Sequence instead of a List