…… 你没有提到 return 有个副作用是下面的代码都别想执行了，那当然是没这个问题了

其次有一个不容易被注意到的细节：?: return 和 ?: throw 居然是一样的，都 TM 是普通版文法
Kotlin 傻逼了！ return 怎么可以是表达式？
你试试 fun op() { println(null ?: return as Nothing) }

iseki 觉得 return 能够和 throw 一样被作为表达式吗 🤔
fun op() { do { println(null ?: continue as Nothing) } while(true) }
我觉得好奇怪啊

我觉得不行，这样容易混淆……
我觉得可以提供语法糖，但不能是表达式

我很讨厌 fun op() { do { println(listOf(return, continue, break, throw Exception())) } while(false) } 可以解析甚至执行的情况

我还是无法接受 continue 可以被作为参数的 case……
println(continue) 我简直发毛
尽管类型层面我们可以检查出 println 不能被执行

我是这样想的，如果没有足够的理由，『控制流』表达式我要有所取舍
比如说，一些能够不作为表达式的，return 什么的就专门提供语法糖

这个问题我可以到时候弄出我设计那个语言第一个编译器的时候再找其他人谈谈，
之前我没考虑过 break 什么的类型级别可以是 Noting 这件事……
我之前以为 Kotlin 是不允许这样，但我得慢慢去想，举出实际使用例子来

其实这也不是没好处，好像是可以放在 block(closure) 里面的，不过我也不是很确定。

我打算设计的这门语言叫『绝句』，这里有一个简单的例子：

引记法 绝句.区间.数域 (投、换)
对何<项>皆有
括物(我: 行<项>) 为
  私下、尾递归的事 二分查找(你: 项、区: 数域): 引数? 为
    量 中针 = 区的中值
    判我[中针]，
      是你，回中针
      大你，重写(区=区投末，中针前。) “逗号文法 确保（一行(1、2、3).全是，它 不小 一。）”
      “二分查找(你, 区.mapBegin { 中针.dec() })”
      小你，重写(区=区换始(中针))
    “编译器知道没有其他情况”

记得我当初设计的时候（重写是后来设计的一个特性）重写被弄成了个值是『断止』类型的表达式 🤔

一个细节是，它在类型层面建模了 Kotlin 没建模的 Exceptions，这个建模被称为『无常类型检查』

//!语者 无例之物
//!语者 此即存储
对何<值者>皆有
密封的内联物 无常 为
  私下的内联物 断止: 无常<*>()
  私下的内联物 决常(量 你: 值者): 无常<值者>() 为
    算符的事 此即值() = 你
  “大致是这样吧，注意这是编译器的 intrinsics”

比如说，假设有 事 读一行(): 无常<文>



尝试，
  量 输入行 取者，读一行()。 “内联类没有『我』分配，无法作为通常值存储”
  “或者，你也可以写 量 输入行 = 读一行()作决常”
  输出 写 输入行 “编译器知道『输入行』的「推帧单位」和赋值语句的是一个，且这一句能执行必定代表无异常发生，智能转型。”
接迎 文件结束不常成『异事』，异事去写出()。 “『标识符』是绝句的一种文法”
  “当然关键字<接迎>后不加空格也可以”
终焉，
  “这只是个例子”

你这指定的好像是类型上界 <T: Any> capture<T extends "Any">？
有时候我觉得类型上、下限好理解些，一个「界」字我觉得断言的不够明显，让人困惑（虽然是通用说法）

就是类型检查啊，Java 都是泛型擦除的实现，Kotlin 有强十倍的类型系统你还璇它……

Java 早些时候（1.5的时候才加的泛型）没泛型才这么干，到处瞎转转
现在 Kotlin 有了，你不多看点 Kotlin 最佳实践，还是先重新学学再说吧，Kotlin 不是 JDK stdlib 辣鸡。

而且什么叫做都是，链表也是么

我给你解释一下，拿一般的那一套，不说什么类型理论、集合不集合值不值的。

既然你已经知道 PECS(producer-extends, consumer-super) 原则什么的，就不说了。
Java 的泛型通配符是一种类型变量，?extends A 配属 A （或者说『小于A』）的任意类型，?super A 配超 A（或者说『大于A』）的任意类型
类型就是谁兼容谁的问题，CharSequence 兼容 String、Number 兼容 Integer, Long, Float，或者说兼容者是被兼容者的子类型(subtype)。
就是说任何操作 (CharSequence) -> * 都可以被 invoke("string instance")
哪怕是 xs[1], xs[2] 这种操作都一样（他们就是 Kotlin 的 operator fun get(index: Int): T） 嘛


泛型加了个参数，不过这里就出了个问题，比如说，

interface Box<T> {
  T get();
  <R> R let(Function<T, R> f);
}

这里我们写点使用者角度的代码，

void printNumber(Number num) { out.println(num); }
// Function<Number, Void> printNumber = out::println;
Box<Integer> ba = new ValueBox(1);
ba.let(::printNumber);

// Box<Integer>#let(Function<Integer, R>) is not acceptable for (Function<Number, Void>)

其实我们谈的 Box<T> 就是 Kotlin 的 Box<in T>，因为它的类型参数只在「消费者位置」出现，你说对应 ?super XXX，很正确，但知道不等于理解，所以要再学。

所以大家都这么写：

  <R> R let(Function<? super T, R> f);

然后对 Java8，it checks，很好可是对理解没帮助，我们应该看看 Function<T, R> 的定义：

interface Function<T, R> { R apply(T in0); }

准确的说是 Function1: (T) -> R.
所以为啥现在可以了，就是因为 Function<T, ...> 里的这个 T 成了 ?super Integer, 所以它关于它的类型参数 T 逆变(contra-variant)了（Scala 的 Function[-T], Kotlin 的 Function<in T> 或者 (T) -> *）。

所以说，为什么现在可以用了，就是因为

对于任意类型 <R>，
Box<Integer>#let(Function<?super Integer, R>) 可以收 Function<Number, R> 类型的实例了

为什么要有输入/输出两种情况，就是比较对象顺序上的差异（我也不知道为什么）
为什么要有型变性，是为了完整化类型系统多态(polymorphism)的代码复用
+ 如果有某个收某类型 A 的操作 Op<A> { void op(A); }, 则对于所有的 Op<A0: ?super A> { void op(A0); } 它肯定能够 op((A) x)，因为它连 A0(如 Number) 都能收自然能够收 A(如 Integer)
+ 如果有某个返回某类型 T 的操作 Ret<T> { T get(); }, 则对于所有的 Ret<T1: ?extends T> { T1 get(); } 它肯定能够 (T)get()，因为它连 T 的子类型都能返回，为什么不能返回 T

然后 Kotlin 的 * (就是说在某个「位置」被一切参数兼容，比如 Consumer<in *> 可以收 Consumer<Int>, Consumer<String>, ...) 在 in 的位置是 in Nothing, out 的位置是 out Any?

Nothing 是 Kotlin 里一切类型的子类(bottom type)、Any? 则是一切类型的超类，所以区间 Nothing..Any? 就代表可接受一切类型
不过区间好像是包含两个比较的，a<=x&&x<=b 代表 x in (a..b), 类型检查只用判一次超类链

—
岂止是没区别，单就泛型看（这还不提 Kotlin 化腐朽为神奇的 T?, (?.) (?:) 操作）都是天壤之别呢，你去看那么多 Java 库，他们类似 Action<T>, Consumer<T> 这种都不得不对每个受参的方法写 Action<? super T>
那种雷轰感，没写过是不会明白的……

Kotlin 的 in/out 都是在类型变量声明处，此外对于 <A, B> fun copyArray(dst: Array<A>, src: Array<B>) 为保证类型安全和代码复用可在 Array<...> 里填 out B, 它会禁止对 set(Int,B) 的访问
（因为如果允许，实际上意味着 (ary as Array<Int>).set(Int, Number) 可以被使用，因为 src 可以是任何 Array<T> where T: Number，这是败坏类型安全性的）（给填 in A 也是可以的，效果一样）

成熟个毛线啊，Java 简直老掉牙了！Kotlin 写十行的代码 Java 不得不写 20 行，有些 Java 程序员能写 40 行，带上所谓的内联文档和注释和『完全覆盖』的测试！

和兼容 Java 没有关系，Java 对泛型兼容也主要是编译器上下工夫，类文件格式其实是没有变化，只是加了点元数据


就是这样