Kotlin 如何递归地在Iterable上实现深度展平？

看过之后，我正在寻找一种

deepflant

，也就是说，它不仅可以与

Iterable

（对于

Array

s几乎相同，但为了简洁起见，现在让我们重点关注

Iterable

），还可以与

Iterable

、

Iterable

等一起使用

---

当然，结果必须是

List

，这是标准

flatte（）

没有提供的-在Java中，它将返回

List，您可以使用以下方法实现相同的行为：

使用
集合：

public static Stream<?> deepFlatMap(Object o) {
   if (o instanceof Collection<?>) {
       return ((Collection<?>) o).stream().flatMap(i -> deepFlatMap(i));
   }
   return Stream.of(o);
}

public static Stream<?> deepFlatMap(Object o) {
   if (o instanceof Iterable<?>) {
       Spliterator<?> spliterator = ((Iterable<?>) o).spliterator();
       return StreamSupport.stream(spliterator, false).flatMap(i -> deepFlatMap(i));
   }
   return Stream.of(o);
}

用于显式指定泛型类型：

MyClass.<Integer>deepFlatMap(list).map(i -> i + 1).forEach(System.out::println);

MyClass.deepFlatMap（list）.map（i->i+1）.forEach（System.out:：println）；
我是否有可能在返回类型中保留最里面的类型？在我的例子中，
Int
？当我们有泛型时，到处抛出
对象似乎有点不合适。谢谢，这似乎是一个不错的解决办法，尽管我将继续尝试将它调整为Kotlin的
序列
，而不是普通Java的
流。
public static Stream<?> deepFlatMap(Object o) {
   if (o instanceof Iterable<?>) {
       Spliterator<?> spliterator = ((Iterable<?>) o).spliterator();
       return StreamSupport.stream(spliterator, false).flatMap(i -> deepFlatMap(i));
   }
   return Stream.of(o);
}

public static <T> Stream<T> deepFlatMap(Collection<?> collection) {
    return (Stream<T>) internalDeepFlatMap(collection);
}

public static Stream<?> internalDeepFlatMap(Object o) {
   if (o instanceof Collection<?>) {
       return ((Collection<?>) o).stream().flatMap(i -> internalDeepFlatMap(i));
   }
   return Stream.of(o);
}

MyClass.<Integer>deepFlatMap(list).map(i -> i + 1).forEach(System.out::println);

fun <T> Iterable<*>.deepFlatten(): List<T> {
    val result = ArrayList<T>()
    for (element in this) {
        when (element) {
            is Iterable<*> -> result.addAll(element.deepFlatten())
            else -> result.add(element as T)
        }
    }
    return result
}
...

println(data.deepFlatten<Int>())

typealias It2<T> = Iterable<Iterable<T>>
typealias It3<T> = Iterable<It2<T>>
typealias It4<T> = Iterable<It3<T>>
typealias It5<T> = Iterable<It4<T>>
//etc...

fun <T> It3<T>.flatten2(): List<T> = flatten().flatten()
fun <T> It4<T>.flatten3(): List<T> = flatten2().flatten()
fun <T> It5<T>.flatten4(): List<T> = flatten3().flatten()
//etc...

...
println(data.flatten2())