A modern programming language that makes developers happier.

kotlinlang

Just found I’ve made a completely invalid assumption about `singleOrNull` - I assumed it would throw an exception if size &gt; 1, but it returns null.

I’d quite like something that asserts an `Iterable&lt;T&gt;` has 0..1 elements by returning a `T?` or throwing an exception if size &gt; 1.

(what’s the term for the types of numbers in a collection? `0`, `1`, `0..1`, `0..*`, `1..*` - it’s not arity…)

Shouldn’t you used Optional instead if you got a construct like that?

Normally I’m choosing `first()`  for sth. like that. Or i’m simply asserting that the collection size is less-equal 1. But don’t quite understand the reason to choose Collection if you are just having zero or exactly one value(s)?

<@UMXTNACBY> this function may do what you want:
```fun &lt;A&gt; Iterable&lt;A&gt;.firstOrThrow(): A =
  if (size &gt; 1) throw IllegalStateException("unexpected size == $size. $this")
  else first()```
but as <@U01FMV7FKLY> said maybe if you have a data structure that can only contain a single potentially absent element then <https://kotlinlang.org/docs/null-safety.html#nullable-types-and-non-null-types|nullable types> it’s a better option.

I’m filtering an Iterable to one or zero.

To add to raulraja's suggestion this possibly fits better with your usecase:
```fun &lt;A&gt; Iterable&lt;A&gt;.singleOrThrow(): A? =
  if (size &gt; 1) throw IllegalStateException("unexpected size == $size. $this")
  else firstOrNull() // Returns A if size == 1 and null if size == 0```

Thanks all - it’s not a problem with writing the function, just surprise at the original one’s behaviour (though as I think about it, it is consistent with other xOrNull behaviour).

(I’s the `singleOrNull(predicate: (T) -&gt; Boolean)` that I was using btw)