我想到了一种好方法，可以解决 if 表达式的问题
再引入以个新「若」语法，就可以回归 Java 的老式风格了

说(若p"你好"否则"再见")
可是这样实在是不好看啊……

说(若a去试等(2)"你好"否则"再见") 

我终于知道三目运算符 ternary 为什么是 p? a : b 那样写了。

……果然最好的方法还是，面向表达式。
反正 控制流和表达式 明明就是一家子的
为什么要强行分开呢

刚才提到了点传统的类型理论，小白肯定蒙蔽吧。
类型是值的集合，会以「a, b, c 值都属于 A 类型」形式描述。
1, 2, 3 都是 Int
1.0, 2.0, 3.0 都是 Double

fun Int.plus(other: Int): Int

是一个操作，接受两个 Int（receiver 处的也算）返回一个 Int
所以你就可以 (1 + 1) + 2 这么用，因为 (1+1) 本身也是 Int

A 和 B 的交集(intersection) 在类型上，就是说一个兼容AB交集的操作，同时兼容 A 和 B 作为输入
比如，Int 和 Double 的交集是 Number，fun Number.toInt(): Int，可以视为两者兼有的操作

A 和 B 的并集(union) 在可以同时视为 A 及 B
比如，Int 和 Double 的并集可以是 Number 以及 Any 以及 Any?

刚才我说 listOf(1, return): List<T> 其中用的操作的签名是 fun <T> listOf(vararg item: T): List<T>
之所以说是 union 不是 intersection 是，举个例子吧，因为它上面的 List<T>.get(Int): T 需要同时兼容输出 Int 和 Nothing，自然是并集喽。

Any? 的意思是除了 Any 原有的元素还可是 null

Kotlin 里那个 in / out 的意思还是从那个类型参数的使用位置来看。

fun main(args: Array<out String>)
就是不让用 Array<String>.set(Int, String) 了

好看嘛，用 fun <CAT> play(cat: CAT) where CAT: CoolCat, CAT: Happyable 可不方便
不然语义实在捉鸡

只是对于集合论的一些符号 化成 ASCII，许多人的理解会 产生分歧
这一点 不是特别容易遇到，但的确是存在的
有些人觉得 A|B 是 intersection 呢
还有人觉得 A^B 是 intersection
也有人吧 A|B 当 union

我是说传统的那种情况，类型被视为集合
那样类型系统就是值和关于值的操作

listOf 的两个参数 String, Int 我们来取一个 union……
interface String: Comparable<String>
interface Int: Number, Comparable<Int>
结果就是 Comparable<T>
两个参数再取 union…… {String & Int}
为了安全，compareTo(other: T) 就必须同时兼容 String 和 Int
就是 Any 啦

至于 Serializeable，那个也都说了是 { {Comparable<A&B>} & Serializable}
是在外面的东西

Int & String 是 Any 或 Any?
fun accept(x: Any) {}
listOf(1, "").forEach(::accept) acceptable

忘了，其实 Int&String 是 Nothing，不过 accept 是 Function<in Any, out Unit>

总之，涉及型变性是视角的不同

fun accept(x: Any?) 是啥类型都能接受，这个上界是最高的『顶类型』，的函数的签名。
op: Function<in Nothing, out *> 这个是描述「啥类型都能接受的函数」的类型

你 op.invoke(error("emm")) 的时候 ? super Nothing 肯定是能接受的
换句话说，那个 accept(Any?) 是可以接受，Nothing 的
……怎么感觉这个问题比较容易讲糊涂

感觉…会不会和Nothing本身的机制有关，比如说Nothing是被跳过去忽略的？🤔

主要还是先在理论上弄清楚，具体的优化不会立刻涉及

“Nothing 是任何类型的子类型，因为这样的值往往你得不到它程序就终止了”
比如 println(error(""))

listOf(1, break) 推导出的是 List<out Int>
因为 Int+Nothing 是 Int
List 需要同时存储 Int 或者 Nothing

其实最重要的是 fun <T> listOf(items: Array<out T>): List<T> 里这个 T 就必须一致化为 Int+Nothing
fun <T> listOf(items: Array<out T>): List<in T> 也一样，反正这个调用的 type parameter 必须一致……

和关系式编程里常用的 unification 算法又不一样，unification 是你知道 x+1 = 2 的情况下利用相等关系解出 x=1
解就是字面意义的那个”解“，因为自然数可以拿许多 Pair 表达，这就是相当于 (x, +1) = ((0, +1), +1) 解构，
x = y = z，x = 1 的时候你求出 z 也是拿相等关系，每次 unify 一下，把 State 里 y 的值设为 x 就可以了

不过一般是你得先给定 x=1，再 unify 关系…… 指简单实现

#zhihu #life https://www.zhihu.com/question/338688699/answer/915442428

#biology 如果一个人全身的DNA全部瞬间断裂或者失活会怎么样？ - 小小的回答 - 知乎
https://www.zhihu.com/question/302871405/answer/626074679

#fix 纠正一下，一个很基本的概念被我弄反了…… 现在改正。

刚才提到了点传统的类型理论，小白肯定蒙蔽吧。
类型是值的集合，会以「a, b, c 值都属于 A 类型」形式描述。
1, 2, 3 都是 Int
1.0, 2.0, 3.0 都是 Double

operator fun Int.plus(other: Int): Int

是一个操作，接受两个 Int（receiver 处的也算）返回一个 Int
所以你就可以 (1 + 1) + 2 这么用，因为 (1+1) 本身也是 Int

A 和 B 的交集"AB"(intersection) 可以同时视为 A 及 B
比如，Int 和 Double 的交集可以是 Number 以及 Any 以及 Any?（因为所有 Number 都是 Any，子类型）

A 和 B 的并集"A+B"(union) 在类型上，就是说一个兼容并集A+B的操作，同时兼容 A 和 B 作为输入
比如，Int 和 Double 的并集是 Number，fun Number.toInt(): Int，可以视为两者兼有的操作

刚才我说 listOf(1, return): List<T> 其中用的操作的签名是 fun <T> listOf(vararg item: T): List<T>
之所以说是 union 不是 intersection 是，举个例子吧，因为它上面的 List<T>.get(Int): T 需要同时兼容输出 Int 和 Nothing，自然是并集喽。

所以说这种集合类型论，主要还是要在算法，或者说关于输入数据类型的『操作』进行检查。

Any? 的意思是除了 Any 原有的元素还可是 null

Kotlin 里那个 in / out 的意思还是从那个类型参数的使用位置来看。

fun main(args: Array<out String>)
就是不让用 Array<String>.set(Int, String) 了，此时这个 Array<T> 的 T=String 是在输入的 position

如果允许，那么 Array<String>.set(Int, A) 和 Array<String>.get(Int): A 里的 A 就可能是各种和 String 有关的类型。

比如先以 in 的限制要求 T，这样输入 Array 必须兼容对 ? super T 的 set。
但 set(Int, T) 的兼容依然是子类型的，此时可以放各种 String 的子类型
这是为了保证最大兼容性，因为 Array<in Any> 的确是可以 set(Int, String)

再以 out 的限制要求 T，这样输入 Array 必须兼容对 ? extends T 的 get。
但是刚刚我们说的 Array<T> 里的 T 已经可以是 ? super T，现在它又能是 ? extends T，这个『类型安全』的区间是空的。
如果一定要呢？那 Array<Any> 之前允许输入(set) Any，现在又可以输出(get) String，是不安全的。

简单点说，+T 协变(covariant)是指 P<T1> 兼容 P<T>，如 Producer<T> 上的 op(): T 要求 Producer<Int> 兼容 Producer<Any>
-T 逆变(contravariant)是指 P<T> 兼容 P<T1>，如 Consumer<T> 上的 op(T) 要求 Consumer<Any> 反而兼容 Consumer<Int>
这一点，与 P<T> 本身是作为输入还是输出被提供是无关的，就是『值需求的类型兼容』问题，比如在 x = it、return it、op(it) 里，都有值需求和类型限制啊。

当然也可以 @UnsafeVariance 启用不安全的强制转换，那就和 Java 差不多了

最高法为 8 位武汉「传谣者」正名。
https://mp.weixin.qq.com/s/-s5yEPYKeDAF6xP6xb1BZA

我又想了一个方法 #jueju

Kotlin 的 block 啊，因为最后给个 return 值是 Nothing 会歧义，只能 return@let 这种，带标签的

那么要不要支持 Kotlin 一样的 block 呢？

算了吧。逗号表示法确定，最后一个单句，如果是表达式，那就有值。

val x = if (p) {
  if (p1) 2
  else 0
} else 1

这样的 不利点，绝句的逗号表示法可以巧妙地回避，因为逗顿句简写里面不能有逗号表示法。

量 名字 = 用户的名字 空则，回。
还是这样，那「空则」的值呢？

最高指示：那就把控制流分析和类型检查分着来，没有 Nothing，反正不能让 throw 有值……

算了还是保持 Kotlin 的做法吧…… 不就是 block 里面的 return 必须加标签么

量 x = 若p，
  回[^] 若p1，2。
  否则，0。
否则，1。

那就这样吧……