为什么在Kotlin中迭代器操作符和Iterable接口之间存在分离？

我对

operator fun iterator（）

和

Iterable

接口之间的分离感到非常困惑。

Iterable

需要的唯一函数是

operator fun iterator（）

，该函数已经内置到该语言中。我不明白为什么会出现这样的情况：您要实现

操作符乐趣迭代器（）

，而不是

Iterable

接口。这就引出了一个问题：为什么不实现相应的接口就可以使某些东西变得可移植？这样做似乎是错误的。同样地，

operator fun next（）

和

operator fun hasNext（）

不应该总是对应于

迭代器类型吗

我试图检查类型是否实现了
operator fun iterator（）
，以查看它是否在幕后自动实现了
Iterable
，但情况似乎并非如此。我能想到的唯一其他原因是与Java迭代器的某种互操作性

class Foo(val n: Int) {
    operator fun iterator() = FooIterator(this) 
    // Shouldn't the language figure out that Foo is iterable?
}

class FooIterator(val foo: Foo): Iterator<Int> {
    var seen = false
    // Implementation goes here
}

fun <T> printAll(iter: Iterable<T>) {
    for (x in iter) {
        println("$x")
    }
}

fun main() {
    printAll(Foo(2)) // Type mismatch: Foo is not Iterable
}

类Foo（val n:Int）{
运算符fun iterator（）=FooIterator（this）
//语言不应该指出Foo是可移植的吗？
}
类FooIterator（val-foo:foo）：迭代器{
var=false
//实现就在这里
}
趣味打印所有（iter:Iterable）{
用于（国际热核聚变实验堆中的x）{
println（$x）
}
}
主要内容（）{
printAll（Foo（2））//类型不匹配：Foo不可编辑
}

实现
iterator（）
、
next（）
和
hasNext（）
、
invoke
等的任何类都将始终实现相应的接口，这是有道理的。为什么语言是这样设计的，但情况并非总是如此？
这是一条一般规则：定义与接口中的函数具有相同名称/类型的函数不会实现接口。为什么
Iterable
和
Iterator
应该是例外？（技术术语是Kotlin中的子类型是，而不是。）

我不明白为什么会出现这样的情况，即您将实现运算符fun iterator（），但不实现Iterable接口

例如，
迭代器
是扩展函数时。在

运算符fun Iterator.Iterator（）：Iterator
运算符fun Map.iterator（）：iterator
@JvmName（“mutableIterator”）运算符fun MutableMap.iterator（）：mutableIterator

而
next（）
/
hasNext（）
（以及
iterator（）
）可以定义为扩展函数，以防您不幸使用它来处理旧代码。
这是一条一般规则：定义与接口中的函数具有相同名称/类型的函数不会实现接口。为什么
Iterable
和
Iterator
应该是例外？（技术术语是Kotlin中的子类型是，而不是。）

我不明白为什么会出现这样的情况，即您将实现运算符fun iterator（），但不实现Iterable接口

例如，
迭代器
是扩展函数时。在

运算符fun Iterator.Iterator（）：Iterator
运算符fun Map.iterator（）：iterator
@JvmName（“mutableIterator”）运算符fun MutableMap.iterator（）：mutableIterator

和
next（）
/
hasNext（）
（和
iterator（）
）可以定义为扩展函数，以防您不幸使用它来处理旧代码。
我的理解是
operator fun iterator（）
，
operator fun next（）
和
operator fun hasNext（）
是在语言语法级别上定义的，即它们是语法构造中使用的对象的低级要求（即
对于
循环）

类示例{
有趣的事{
for（NotIterable（）中的一个名词）{
...
}
}
}
类不可分{
//返回的“迭代器”实际上不是迭代器实例
//它只是一个碰巧具有正确功能的对象
运算符fun iterator（）：NotIterator{
return NotIterator（）
}
}
类非迭代器{
运算符fun hasNext（）：Boolean{
...
}
运算符fun next（）：Int{
...
}
}

另一方面，在语言库中定义了
Iterable
和
Iterator
。它们是在运算符函数的基础上构建的，并添加了丰富方便的API，包括许多扩展函数。
我的理解是，
operator fun iterator（）
，
operator fun next（）
和
operator fun hasNext（）
是在语言语法级别定义的，也就是说，它们是对语法构造中要使用的对象（即
for
循环）的低级要求

类示例{
有趣的事{
for（NotIterable（）中的一个名词）{
...
}
}
}
类不可分{
//返回的“迭代器”实际上不是迭代器实例
//它只是一个碰巧具有正确功能的对象
运算符fun iterator（）：NotIterator{
return NotIterator（）
}
}
类非迭代器{
运算符fun hasNext（）：Boolean{
...
}
运算符fun next（）：Int{
...
}
}

另一方面，在语言库中定义了
Iterable
和
Iterator
。它们构建在操作符函数之上，并添加了丰富方便的API，包括许多扩展函数

operator fun <T> Iterator<T>.iterator(): Iterator<T>
operator fun <K, V> Map<out K, V>.iterator(): Iterator<Entry<K, V>>
@JvmName("mutableIterator") operator fun <K, V> MutableMap<K, V>.iterator(): MutableIterator<MutableEntry<K, V>>

class Example {
    fun someFun() {
        for (anInt in NotIterable()) {
            ...
        }
    }
}

class NotIterable  {

    // the 'iterator' returned is not actually an Iterator<> instance
    // it just an object which happen to have the right functions
    operator fun iterator() : NotIterator {
        return NotIterator()
    }
}

class NotIterator {
    operator fun hasNext(): Boolean {
        ...
    }

    operator fun next(): Int {
        ...
    }
}