Anyone else feel this (`trySingle` for collections...

# language-proposals

[Emil Kantis]

Anyone else feel this (trySingle for collections) would be useful as part of the stdlib? Or have any alternate solutions? 🙂

fun doSomething(customerId: Int) {
   val user = when (val result = fetchExistingUsers().trySingle { it.id == customerId }) {
      is MultipleFound -> error("Duplicate users for single ID")
      is NoneFound -> createUser()
      is Single -> result.single
   }
}

[Emil Kantis]

Currently implemented on my own as follows.. trySingle is a slightly modified singleOrNull

sealed interface TrySingleResult<out T>

class Single<T>(
   val single: T
) : TrySingleResult<T>

object MultipleFound: TrySingleResult<Nothing>
object NoneFound: TrySingleResult<Nothing>

inline fun <T> Iterable<T>.trySingle(predicate: (T) -> Boolean): TrySingleResult<T> {
   var single: T? = null
   var found = false
   for (element in this) {
      if (predicate(element)) {
         if (found) return MultipleFound
         single = element
         found = true
      }
   }
   if (!found) return NoneFound

   @Suppress("UNCHECKED_CAST")
   return Single(single as T)
}

[ephemient]

this is something that Scala's pattern matching would work on,

fetchExistingUsers().filter { _.id == customerId } match {
    List(singleId) => singleId
    List(_, _*) => error(...)
    _ => error(...)
}

there isn't a finished design for what it would look like in Kotlin, but https://youtrack.jetbrains.com/issue/KT-186 may be coming in a future version of Kotlin

[hfhbd]

For this specific use case you could use filter and check its size.

[Emil Kantis]

Thanks @ephemient, that looks very interesting and the scala approach seems elegant and applicable to a wide variety of use-cases 🙂

@hfhbd I'm aware, but it breaks the handling of all branches into multiple statements. The when-clause forces you to deal with all branches immediately (multiple, single and none). I think it's generally preferable

[ephemient]

when (result.size) { 0 -> ; 1 -> ; _ -> }

[ephemient]

not the most elegant but that would work as well

[hfhbd]

fun doSomething(customerId: Int) {
   val user = fetchExistingUsers().filter { it.id == customerId }.let {
      when(it.size) {
      0 -> createUser()
      1 -> it.single()
      else -> error("Duplicate users for single ID")
   }
}

[Emil Kantis]

Another alternative: trySingle(predicate: (T) -> Boolean): Result<T?> using Kotlin's built-in Result-type.. Then you can do something like:

fun doSomething(customerId: Int) {
   val user = fetchExistingUsers()
      .trySingle { it.id == customerId }
      .getOrElse { println("Multiple found") }
      ?: createUser()
}

[Emil Kantis]

@hfhbd nice, clever to use let to scope the result before using when 🙂