Mark
03/12/2021, 3:37 AMrawItem
should not be exposed (and I would rather pass around LazyItems
than LazyItems<Foo>
). In other words, I want a kind of private R
generic.
class LazyItems private constructor(
private val rawItems: List<Any>,
private val processItem: (Any) -> Item,
) {
fun consumeItem(): Item {
val rawItemToConsume = someFun(rawItems) // Any
return processItem(rawItemToConsume)
}
companion object {
operator fun <R: Any> invoke(
rawItems: List<R>,
processItem: (R) -> Item
) = LazyItems(rawItems) {
processItem(it as R)
}
}
}
It’s a shame you can’t do something like:
class LazyItems constructor <R : Any> (
private val rawItems: List<R>,
private val processItem: (R) -> Item,
) {
Joel
03/12/2021, 9:48 PMclass MappedIterator<T, R>(
private val delegate: Iterator<T>,
private val transform: (T) -> R,
) : Iterator<R> {
override fun hasNext() = delegate.hasNext()
override fun next() = transform(delegate.next())
}
class MappedIterable<T, R>(
private val delegate: Iterable<T>,
private val transform: (T) -> R,
) : Iterable<R> {
override fun iterator() = MappedIterator(delegate.iterator(), transform)
}
fun <T, R> Iterable<T>.mapLazily(transform: (T) -> R): Iterable<R> = MappedIterable(this, transform)
I don't follow why passing around LazyItems<Foo>
is an issue. That's using the language as intended, for better or for worse.Mark
03/13/2021, 3:09 AMLazyItems
.