Kotlin’s Iterable and Sequence look exactly same. Why are two types required?

by

The key difference lies in the semantics and the implementation of the stdlib extension functions for Iterable<T> and Sequence<T>.

  • For Sequence<T>, the extension functions perform lazily where possible, similarly to Java Streams intermediate operations. For example, Sequence<T>.map { ... } returns another Sequence<R> and does not actually process the items until a terminal operation like toList or fold is called.

    Consider this code:

    val seq = sequenceOf(1, 2)
val seqMapped: Sequence<Int> = seq.map { print("$it "); it * it } // intermediate
print("before sum ")
val sum = seqMapped.sum() // terminal

    It prints:

    before sum 1 2

    Sequence<T> is intended for lazy usage and efficient pipelining when you want to reduce the work done in terminal operations as much as possible, same to Java Streams. However, laziness introduces some overhead, which is undesirable for common simple transformations of smaller collections and makes them less performant.

    In general, there is no good way to determine when it is needed, so in Kotlin stdlib laziness is made explicit and extracted to the Sequence<T> interface to avoid using it on all the Iterables by default.

  • For Iterable<T>, on contrary, the extension functions with intermediate operation semantics work eagerly, process the items right away and return another Iterable. For example, Iterable<T>.map { ... } returns a List<R> with the mapping results in it.

    The equivalent code for Iterable:

    val lst = listOf(1, 2)
val lstMapped: List<Int> = lst.map { print("$it "); it * it }
print("before sum ")
val sum = lstMapped.sum()

    This prints out:

    1 2 before sum

    As said above, Iterable<T> is non-lazy by default, and this solution shows itself well: in most cases it has good locality of reference thus taking advantage of CPU cache, prediction, prefetching etc. so that even multiple copying of a collection still works good enough and performs better in simple cases with small collections.

    If you need more control over the evaluation pipeline, there is an explicit conversion to a lazy sequence with Iterable<T>.asSequence() function.

More Related Contents:

  1. How to make clickable listview in android using kotlin
  2. What is a “receiver” in Kotlin?
  3. Kotlin and Immutable Collections?
  4. Kotlin: how to pass a function as parameter to another?
  5. What does ?: do in Kotlin? (Elvis Operator)
  6. How to run Kotlin class from the command line?
  7. Is Kotlin “pass-by-value” or “pass-by-reference”?
  8. Multiple variable let in Kotlin
  9. How can I detect a click with the view behind a Jetpack Compose Button?
  10. Example of when should we use run, let, apply, also and with on Kotlin
  11. When should one prefer Kotlin extension functions?
  12. How to create a fat JAR with Gradle Kotlin script?
  13. Why does this Kotlin method have enclosing backticks?
  14. Why does mutableStateOf without remember work sometimes?
  15. How to make “inappropriate blocking method call” appropriate?
  16. IntArray vs Array in Kotlin
  17. How to clone object in Kotlin?
  18. Cross references in type parameters
  19. Sort collection by multiple fields in Kotlin [duplicate]
  20. Swift ‘if let’ statement equivalent in Kotlin
  21. How can one add static methods to Java classes in Kotlin
  22. How do I initialize Kotlin’s MutableList to empty MutableList?
  23. Difference between ArrayList() and mutableListOf() in Kotlin
  24. What’s the difference between !! and ? in Kotlin?
  25. How do I replace duplicate whitespaces in a String in Kotlin?
  26. Kotlin data class: how to read the value of property if I don’t know its name at compile time?
  27. Kotlin Foo::class.java “Unresolved Reference: Java” error
  28. How does erasure work in Kotlin?
  29. kotlin program error: no main manifest attribute in jar file
  30. Why do we use “companion object” as a kind of replacement for Java static fields in Kotlin?

Leave a Comment