Kotlin Efficiency for Iterator of One - kotlin

Question

Given something that implements Iterable<*>.
Most implementations return an iterator that iterates >1 values.
I'm creating a specific implementation that returns an iterator that iterates 1 value.
What is the best implementation?
Given the implementation implements Iterable<Any>, and has a property named value of type Any:
override fun iterator(): Iterator<Any> = iterator {
return#iterator this.yield(this#ExampleIterable.value)
}
Is this the most efficient (albeit, not most concise) implementation of a single-element iterator?

Answer 1

That is far from the most efficient implementation on the JVM, if you are not considering conciseness. The following, for example, would be more efficient:
override fun iterator() = object: Iterator<Expression> {
var nextCalled = false
override fun hasNext() = !nextCalled
override fun next(): Expression {
if (nextCalled) {
throw NoSuchElementException()
}
nextCalled = true
return value
}
}
or as an inline function:
inline fun <T> iteratorOfOne(crossinline elem: () -> T) = object: Iterator<T> {
var nextCalled = false
override fun hasNext() = !nextCalled
override fun next(): T {
if (nextCalled) {
throw NoSuchElementException()
}
nextCalled = true
return elem()
}
}
For one, this doesn't use coroutines like the iterator function does, so it avoids a lot of the overhead that coroutines create. For something as simple as an iterator returning a single element, the overhead of coroutines could be quite a lot.
Looking at the bytecode, you can see that it first instantiates the inner class that represents the lambda return#iterator this.yield(this#ExampleIterable.value), and then calls SequencesKt.iterator.
The lambda inner class actually implements state machine-like thing, kind of like what I did with nextCalled, but with an Int instead, and some added coroutine overhead.
For example, iterator { yield(Any()) } produces the following invokeSuspend implementation in the inner class (decompiled to Java):
int label;
#Nullable
public final Object invokeSuspend(#NotNull final Object $result) {
final Object coroutine_SUSPENDED = IntrinsicsKt.getCOROUTINE_SUSPENDED();
switch (this.label) {
case 0: {
ResultKt.throwOnFailure($result);
final SequenceScope sequenceScope;
final SequenceScope $this$iterator = sequenceScope = (SequenceScope)this.L$0;
final Object o = new Object();
final Continuation continuation = (Continuation)this;
this.label = 1;
if (sequenceScope.yield(o, continuation) == coroutine_SUSPENDED) {
return coroutine_SUSPENDED;
}
break;
}
case 1: {
ResultKt.throwOnFailure($result);
break;
}
default: {
throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
}
}
return Unit.INSTANCE;
}
Then iterator makes an Iterator implementation out of that coroutine. The source code looks like this:
public fun <T> iterator(#BuilderInference block: suspend SequenceScope<T>.() -> Unit): Iterator<T> {
val iterator = SequenceBuilderIterator<T>()
iterator.nextStep = block.createCoroutineUnintercepted(receiver = iterator, completion = iterator)
return iterator
}
Again, more stuff that doesn't actually need to happen, if you've just created and returned an instance of Iterator<T> yourself.
The point is, there is a lot of overhead with creating a whole coroutine just to make a single-element iterator. In the grand scheme of things, this might not matter - you probably have other code that does way more work than this - but if we are just comparing these things in a vacuum, then creating an anonymous class is faster.