Facebook Messenger is removing the ability to find someone by entering their phone number

Facebook Messenger正在删除通过输入其电话号码来查找某人的功能

来源：
https://twitter.com/wongmjane/status/1210864489358184448

翻译成中文就是

量 userProfile：AlipayProfile
@GetMapping @RequireRoles("consumer") 取者，
  回 currentUser 令为(alipayUserService去::getProfile)
  ?去令为(::AlipayProfileData)
  空则，抛下BusinessEx("unexpected_exception") 。

接着翻译就是
量 用户资料：支付宝资料传输 【身份要求 "消费者"】
【GET路径】的取者，
回 当前用户令为(支付宝用户服务去::取资料)?
去令为(::支付宝资料传输)
空则，抛下BusinessEx("unexpected_exception")。

以前我偶尔以『艺术品』的心态想到『用中文写程序』，把中文看得比编程重，结果写出来的东西不像中文更不能编程。

现在我多学习了几门『不常见』的编程语言，Haskell、Scala、Kotlin，结果写出来的东西不仅符合编程逻辑而且像中文，这真是奇怪啊。

如果你连文字都不会敲、逗号顿号傻傻分不清，是设计不出『中文编程语言』的，这一点不必多说吧。

FONT = Font.FreeTypeFont.read('/usr/...')
(BASE_X, FIXED_Y) = (..., ...)
def compositeText(s):
img = Image.open('panda.png')
(txtW, txtH) = FONT.getSize(s)
txtWd2 = txtW/2 #atom layout calc (width-balance)
img.draw_text(x=(BASE_X-txtWd2), y=FIXED_Y, font=FONT, text=s)
return img #effect
def main():
for text in input().split(" "):
img = compositeText(text)
img.save(f'panda_{text}.png')

别测试，我说着玩的，没看见我没写导入吗？ 😂

其实我把 Binarie 的类图都画好了，难点也的 swapIntegral, fromIntegral, toIntegral 也整理到 Convert.kt 里了，可就是没时间实现了，算。
其实 ParserKt 也一样，我完全建模好了 Input 和 Parser（以及 PredicateParser:AtomParser, ReduceParser, Seq, Repeat、OrParser） 架构，可就是没时间实现…… 也是天注定吧。

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/index.html

试着定义一些绝句的核心类型，至于绝句如何翻译至多门语言…… 只当下面是Kotlin翻译目标专属的。

包 绝句

‘绝句中任何「物」的基础物，位于继承树的最顶端。’
开放的物『值』 “公开的造于()” 为
‘将[我]与[另]进行相等性判断。若等价，回真。’
‘[另] 比较宾语，`1是2`里的`2`。’
‘实现必须满足以下性质（这里 _斜体_ 都是非空 [值]）：
+ 自反性(reflexive)：对何 _x_，`x是x`成立。
+ 对称性(symmetric)：对何 _x_、_y_，若`x是y`，`y是x`成立。否则`y是x`定不成立。
+ 传递性(transitive)：对何 _a_、_b_、_c_，若`a是b`且`b是c`，`a是c`成立。
+ 一致性(consistent)：对何配对的 _a_、_b_，任意次执行`a是b`结果不变，或者说它是纯函数(pure function)。
+ 非空判断：对何 _x_，`x是空`不成立。`空是空`成立。 ’
【内建 "Any.equals"】待例、开放、算符的事 问等(另：值?)：真假
‘取此值的哈希码。对于 [为等] 的值，哈希码总是一致的，即便其一「不即是」另一。’
【内建 "Any.hashCode"】待例、开放的事 化记码()：记码
‘取此值的文本化表达’
【内建 "Any.toString"】待例、开放的事 化文()：文

啊好累啊，会不会是绝句的文档写起来麻烦……

此外还有好多应该定义的，
Annotation 注解，这个只是个标记

Comparable 有序<入T>
算符 求序(另：T)：序
例物 序 { 大、小、等 }

属别名 顺序<T> = (T、T)有序.序

Array<T> 组：可度(Sized) size大小 算符们：get取 set置 iterator建迭子
还有算符 component1-5
有许多组一 组空 组全空

  fun <reified T> emptyArray(): Array<T>
  对何<真项>皆有待例的事 组空()：组<项>
  fun <reified T> arrayOfNulls(size: Int): Array<T?>
  对何<真项>皆有待例的事 组全空(计：计数)：组<项?>
  fun <reified T> arrayOf(vararg elements: T): Array<T>
  对何<真项>皆有待例的事 组一(许多的内容：项)：组<项>

当然这个待例是【内建】的……
当然，它可以这样调用，我还没设计 spread 语法……

  组一(*xs)

还有许多的 Unboxed array：Boolean/Byte/Short/Char/Int/Long/Float/Double Array
CharSequnece 字符序列：可度

Annotation 里的也可以

  【路径们 3、[1, 2, 3]】

Cloneable 可复制
Closeable 可关闭
Throwable 可抛下
Serializable 可化串
Pair 元二
Triple 元三
String 文
Nothing 断止
Unit 效果
Version 绝句.核心库版本
Function<in T, out R> 对何<入T、出R>皆有物 函数 算符的事 用
Lazy<T> 惰性求值<值者>
例物 并发安全 { 安全、实例一致、不安全 }
Exception 错误 （接迎XX错误我觉得没啥不对的……何况异常和错误很多时候对它们的区别是让人莫名其妙的）
Error 失败
RuntimeException 运行时错误
ArithmeticException 运算错误
IndexOutOfBoundsException 索引越界错误 （一般人写程序都不会出这种错误，所以不作简化）
ClassCaseException 作属断言错误（还分 Java 的、Kotlin 的、绝句的……）
IllegalArgumentException 参数断言失败
IllegalStateException 状态断言失败
AssertionError 断言失败：失败（绝句正好反着来，Exception=错误、Error=“异常”，Error是主动的所以叫失败、Exception是被动的而我又不想破坏中文语言习惯所以这么叫）
NoSuchElementException 项目未找到错误
NotImplementedError 尚待实现失败
NoWhenBranchMatchedException 分支穷举性断言错误（据说Common里没有）
UninitializedPropertyAccessException 属性未初始化访问错误
UnsupportedOperationException 操作未支持错误
NullPointerException 非空断言错误（还分 Java、Kotlin、绝句的）
NumberFormatException 数值解析错误
OutOfMemoryError 内存耗尽失败
Closeable 可关闭
Enum<ENUM: Enum<ENUM>>: 有序<ENUM>(name: String, ordinal: Int) 枚举项
为等、化记码、化文
abstract Number 数值
to (Byte/Short/Char/Int/Long/Float/Double)
以及 Byte, Short, Char, Int, Long, Float, Double 这些加了 Comparable 的
Boolean: Comparable<Boolean> 真假
算符 且、或、非……
记法「异」
为等、化文、化记码
扩展个 『化字节』 就可以了，但我不打算让 `true>false`，看不出有什么意义。

ConcurrentModificationException 并发变动错误（暂时这么叫？
This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.

DeprecationLevel 弃置级别
Deprecated
SinceKotlin
Suppress, ReplaceWith
UnsafeVariance
Volatile 并发易变
Synchronized 完全同步
BuilderInference
大概就是这么说：

fun <T> sequence(block: @BuilderInference suspend Scope<T>.() -> Unit): Sequence<T>
val seq = sequence { yield(1) }

靠着 Scope<T> 上的 yield(T) 就能够推断出 Scope 的类型
我不会……

PublishedApi 事实开放
OptionalExpectation 可无实际
ParameterName 默认名

emm

然后看看一些基本的算符……
inc后 dec前
plus加+ minus减- times乘* div除/ mod取余
unaryMinus取负-@

扩展的位运算，我打算把他们放在专门的包里
and与「位交」 or或「位并」xor异或「位异」
shl左移「左移」shr右移「右移」

val KProperty0<*>.isInitialized: Boolean

量
fun TODO(reason: String): Nothing

fun Throwable.addSuppressed(exception: Throwable)
val Throwable.stackTrace: Array<StackTraceElement>

fun assert(value: Boolean, lazyMessage: () -> Any)
fun assert(value: Boolean)
fun check(value: Boolean)
fun require(value: Boolean)
fun <T : Any> requireNotNull(value: T?): T
fun <T : Any> checkNotNull(value: T?): T
fun <T : Enum<T>> enumValues(): Array<T>
fun <T : Enum<T>> enumValueOf(name: String): T

lazy, lazyOf
isFinite, isInfinite, isNaN
fun Double.toBits(): Long
fun Double.Companion.fromBits(bits: Long): Double
fun Double.toRawBits(): Long
fun Int.toBigInteger(): BigInteger
fun <T> Pair<T, T>.toList(): List<T>

fun <R> synchronized(lock: Any, block: () -> R): R
fun <R> runCatching(//令试

operator fun String?.plus(other: Any?): String
fun Any?.toString(): String
fun Any?.hashCode(): Int

“包 绝句.额联”定记法「接」
扩物『文』 为
待例、记法「接」的事 接(右：文)：文

定记法「~次」
扩物『数』 为
记法「~次」的事 次：计次“……”
内联的事 计做(次：计次、动作：(计数)效果) 为
对次里的计，动作(计)。
……

语言内部的 ranges (progession), annotation 当然是需要的
考虑一下好像也需要 collection(Iterable可迭, Collection合, Slice切片, List行, Set集, Map表), math, text, system, io, delegates 甚至 time, reflect 这样的包。

此时和Kotlin差的除了Unsigned integer和suspend、Result<T>不多了。

唉突然莫名觉得好失望啊，做了那么多东西其实Kotlin早就有解决方案了，我还以为更好呢。

也是，绝句设计其实现在没啥时间的，还能指望什么有价值，文法上做点好东西就行了，其实类型系统本来不想的话也不必定义的。

Kotlin已经这么完善，直接翻译到Kotlin好了

inline class Result<out T> : Serializable

靠，我自己之前设计出内联类啊……Kotlin里现在也有了（虽然它早都有了，呵呵）
内联类什么的还是绝句编译器自己实现吧，免得要开Experimental以及语义差别。

对何<出值>皆有
内联物 结果：可化串……

我觉得还是苦它一点，先做成一个直接的翻译器吧…… 反正项目结构简直是和 Kotlin Van 全一致啊……

除了包命名空间的解析还是要自己做（记法的依赖），好像都没啥可说的了。

其实PKNF的形式化定义早就写出来了，而且PKNF语法本身就是上下文相关的（现在定义写在纸面上），所以说就语法而谈技术上是不存在难题。无论是『汉语编程』、自定义中缀、Layout布局、逗号表示法、汉字数值……
所以绝句应该在现在就可以开始整理语言和核心库设计了，不过在那之前我必须先把那个 Sakura 扩展lambda演算计算器的一部分弄出来，然后拿 ParserKt 尝试解决中文数值、自定义infix、布局文法的问题。（为了弄一个能被快速实现的『脚本语言』我之前有刻意简化Sakura呢，所以等这个叫Sakura的脚本语言发布之前会有一个语法比较类似的玩具能够测试各种东西）

#Android #dev #tech 之前打算重构的e2im，其实草稿都打好了……

1. unsigned long long in 32-bit 检查是为何而定（这部分逻辑我是抄的，但不是复制粘贴
2. 'newline' bug in result protocol （已修复）
3. check errno always single digit, for result protocol limitation
4. prototecting(variable, op) and foreach(name, begin-end iterable, op) rewrite in functional subprocedure form
5. extract takeWhile functional abstraction
6. [Kotlin] retry -> runFailures
7. extract non-su mode superclass
8. specify error code semantics
!1 open fail
!2 file not exists
!3 file not supported
9. [Kotlin] add helper for ListFlags
getWithItem(.): Array<Pair<T, Boolean>>
setWithItem(flags: Array<Pair<T, Boolean>>)
mapWithItem(f):Unit = set(get().let(f))
10. extract: abstract class ChildProcessIntract

谈范畴论：无id箭头如何
负片夜间模式(Canvas, img_cache.js, initNext(), show()=show(next);hide(this), hide()=hide(this);show(prev))
digraph 某人 {
rankdir=BT;
somebody [label="某人", shape=record];
me [lable="我"];
motherOf [label="某人的母亲"];
me -> somebody [label="coprod"];
motherOf -> somebody;
}
f: a -> b to forall a b. f: a -> b

还有就是这个，此外还应该提醒学会数据的依赖分析，这个其实主要还是看思想，实践是最好的方法。 #learn

比方说：

import java.lang.System.`in` as stdin
val input = Scanner(stdin)
val a = 1
val c = a + if (p) a else input.nextInt()

这就要求你有看出这个 c「偶尔」需要依赖 input 的（对象状态）意思。
还有，input 本身可能有状态，在控制流图(CFG, Control Flow Graph)和计算、副作用的产生中可能有怎么样的变化，必须清楚。
最基本的：给你一个 val c，你要知道求出它需要依赖什么数据，如果有些断言要做，你得知道哪些情况叫『正常程序状态』『正常代码路径/程序路径』有哪些则是可能错误的。

另外，要知道一些东西不能太注意刻板的风格，要更加在意可读性。
比如，像 Android Gradle 插件里的 android {} DSL
首先我们知道 compileSdkVersion 是不能缺的，而且对 android {} 来说只用指定一次也没同样重要的东西，所以它可以不折行直接放在 android { 后，目的是体现它与这块定义的关联性。
再如，minSdkVersion 和 targetSdkVersion 不是一个区间范围（没有说高于 targetSdkVersion 不能用的），但可以认为它们应该被写在一行内，不会引起歧义也并不莫名其妙。
versionCode 和 versionName 也是一样的。
偶尔该加的分号要加，这点和『优雅的顺序』思想是一致的。
这样，他们在基于行号的VCS里如果改一个记录会显示只有一行的变动，不过相信没人会必要这个吧。

然后是要有抽提的逻辑，比如，我们这里有一个Android活动：（不要喷，只是个例子而已，另外错了请不失风度地指出，谢谢）

class SomeButtonfulActivity: Activity() {
  //KotterKnife
  val btn0: Button by bindView(R.id.main.btn_0)
  val btn1: Button by bindView(R.id.main.btn_1)
  val btn2: Button by bindView(R.id.main.btn_2)
  override fun onCreate(savedState: Bundle) {
    super.onCreate(savedState)
    //no-op ...?
    btn0.onClickListener = {_ -> toast("wtf")}
    btn1.onClickListener = {_ -> toast("wttf")}
    btn2.onClickListener = {_ -> toast("wtttf")}
  }
}

我们就不说 Activity 本身可继承、可抽提这件事了（可以对其中 onCreate, onResume 的逻辑等各另加组合，抽象出简单适体一点的版本给子类实现）
我们也不说其实 Activity 用 Intent 模型虽然是不得以（因为建模如此，而且语言层面也不好做什么）导致但不好看的问题了（理论上更优雅的Activity应该是带架构器参数而不是动态取参数的，否则也不该是类的形式，单实例就够了）

我们也不说 Kotter Knife 没有用 Annottion Processor 以及 Kotlin 的 first class delegates (delegated properties) 的事了。
我们也不说其实 onClick= 完全可以写在 init{} 里这件事，没必要覆盖 onCreate 这件事了……
我们也不考虑 onCreate 和其它 lifecycle event 比如 onResume 有啥区别了……
我们也不谈 Qt 的 signal/slot、.NET 的 event、Android 的传统 Listener 什么的有啥异同。

这里说说上面的一大堆 btnx.onClick { _ -> toast("...") } 怎么抽提
以前辣鸡Jawa弄得什么 anonymous subclass instance，害得那时候又年轻又阳光又帅气的我都看不懂那些代码，嘤嘤嘤。
相信写了很久Java但是不知道 new XXX() {@Override...} 啥意思的人不止我一个，以致于后来换Java8了，很多Android开发者依然不知lambda为何物。另外一些开发者则出于某些媒体拙劣的宣传把虚拟机的invokedynamic扩展和lambda挂钩了，根本不去注意一下Java8的代码dexer出来带RuntimeDesugar（其实Java8的()->也的确是sugar）。

一句话：
val buttons = listOf(btn0, btn1, btn2)
val texts = "wtf wttf wtttf".split(" ")
for ((btn, text) in buttons.zipWith(texts)) btn.

onClickListener

= { _ -> toast(text) }

稍微有点常识的人不难看出，里面那个 { _ -> } 的闭包依赖 for 里面某次的 text 数据引用。
对这里的闭包关键的一点是：for 有多少次迭代就有多少 { _ -> ...text... } 产生，所以说偶尔闭包其实也不能那么『直观』地看尽管它本身设计目的之一就是为了直观（其实也没有……）。

然后 Kotlin 的 single abstract method interface @FunctionalInterface 实现就不用说了
然后有些东西我也不懂

另：试试多加许多的 Button 然后动态创建（不是说用Anko）
typealias Consumer<T> = (T) -> Unit
Map<String, Consumer<User>> 怎么样？其实动态创建还是动态注册监听差不多。


最后的最后我想说一个问题，当然是我之前的一次误解 #web #JavaScript #fix

function fixedRateSchedule(time_ms, op) {
  op(); setTimeout(() => fixedRateSchedule(time_ms, op), time_ms);
  //也可以直接用 Function.prototype.bind
  //语义上我们创建了一个依赖它上次调用的参数(是全等)引用的 fixedRateSchedule 闭包，实际上是不是新闭包可以自己用 (===) 判断。
}

你们说这个函数有没有『递归(recurse)』？
它有没有调用自己？答案是没调用自己，只是它做的操作引用到了自己而已。

递归的情况栈深度是除『基线』外每层调用往上涨的，非递归情况不变或者下降。

setTimeout 哪怕是timeout=0，也只可能在当前

fixedRateSchedule

实例的栈帧弹出（返回）后执行（要不然就不叫timer了），所以栈深度不变，没有递归。
（当然这不是递归最根本的特征，我只是详细说一个侧面的特征方便学习研究之用而已）

好吧这也不一定，尽管JavaScript是很单线程的语言，timeout=0 的具体情况也是看是否能抢断当前执行子程序的执行权而定的，这里假设timer需要等待应用程序的逻辑没在执行，而是回到底层的运行时库在维护工作状态时才能工作。

接下来准备弄Binarie…… 🤔
弄完我把这周学校里的绝句设计笔记拿来抄抄。

ParserKt 明天再和新的计算器一起写