Flatten iterator of two dimensional array in Kotlin - arrays

Question

I have a Grid class which is wrapper over 2d array of Cell objects. I would like this class to implement Iterable<Cell> interface in order to use it in loops and iterate directly overall cells. Is there a simple way to do that? Does Kotlin support yield return style iterators? My current solution is quite verbose:
override fun iterator() = object : Iterator<Cell> {
val currentOuter = grid.iterator() // grid is object of Array<Array<Cell>>
var currentInner = if (currentOuter.hasNext()) currentOuter.next().iterator() else arrayOf<Cell>().iterator()
override fun next(): Cell {
if (!hasNext()) {
throw NoSuchElementException()
}
return if (currentInner.hasNext()) {
currentInner.next()
} else {
currentInner = currentOuter.next().iterator()
currentInner.next()
}
}
override fun hasNext(): Boolean {
return currentInner.hasNext() || currentOuter.hasNext()
}
}

Answer 1

Does Kotlin support yield return style iterators?
Yes, it does, through the feature of coroutines. Here's a self-contained example:
data class Cell(val d: Int)
val grid: Array<Array<Cell>> = arrayOf(arrayOf(Cell(1), Cell(2)), arrayOf(Cell(3), Cell(4)))
fun cellSequence() = buildSequence {
grid.forEach { it.forEach { yield(it) } }
}
fun main(args: Array<String>) {
cellSequence().forEach { println(it) }
}
Although this particular problem could have been simply solved with just a flatMap, the presented code can serve as a template to write any kind of procedural-looking code, for example:
fun complexCellSequence() = buildSequence {
yield(Cell(-1))
if (grid.size <= 2) {
yield(Cell(2))
}
for (row in grid) {
if (row.contains(Cell(1))) {
yield(Cell(1))
} else {
yield(Cell(12))
row.forEach { yield(it) }
}
}
}
This would be quite nontrivial to rewrite without coroutines.

Answer 2

A very simple solution would be something like this:
val grid: Array<Array<Cell>> = ...
override fun iterator() : Iterator<Cell> = grid.flatMap { it.asList() }.iterator()