#gist #Kotlin 就这样... 感觉可以写一些 Android 平台的东西了，IDEA 的 library view 很好用，可惜我还不知道 Class hierarchy 怎么看

其实我不懂 Kotlin... 即便是 Kotlin 极简教程上也没讲 Kotlin 元编程
我不知道 by operator 是怎么工作的...

刚才看了一些 Android API28 平台包，了解到了：

+ android.os.Paracel 其实就是 Android 的 Protobuf，被称为 Message 的...
+ Praacelabel 就是可以写到 Paracel 上的东西...
+ android.os.Bundle 就是有类型检查的 Map
+ android.content.Intent 有 Category, Action 和 ClassName
+ android.util.ArrayMap 的容器（bin）是 Array 而不是 LinkedList、扫描算法是二分查找，故此称为 ArrayMap
+ 有一个 android.util.SparseArray 但我不知道是哪种东西

+ Android 有内建的 JSON 和 Base64 支持
+ 如果你要在 Gradle 里用 plugin: 'com.android.library' 和 plugin: 'kotlin'
不能这么做，要不然你就会和我一样浪费至少半个小时的时间调整 Gradle 和 Gradle Android 的版本...
然后搜索 Android Plugin 的源代码并最终发现其实 Andriod 插件所谓的“不兼容”不是指 Java 插件版本不兼容，而是 android 根本不能和 java 一起 apply...

必须用 plugin: 'kotlin-android' 替换默认 kotlin

+ Kotlin JVM 的默认 Maven coordinates: "org.jetbrains.kotlin:kotlin-stdlib-jdk8:+"
+ Android AndroidManifest XML 的 Schema URI: "http://schemas.android.com/apk/res/android"

AsyncTask 其实就是基于消息队列事件的异步，是解决 Android 的 "UI 线程" "Worker Thread" 不对称问题的

#Telegram 太好了！

Now you can share the public channel's link and view the content in a browser.

Copy and open it in a browser:
t.me/s/durov
t.me/s/telegram
t.me/s/tgbeta
t.me/s/username

Note:
The contents aren't updated real time, currently for preview.

Credit: KeralaGram

https://t.me/s/dsuse 这样看起来会方便很多，也给了我用 Telegram 而不是写 Markdown/HTML 的动力

(define (histogram vector-of-words)
(define hash (make-hash))
(for ([word (in-vector vector-of-words)])
(hash-set! hash word (add1 (hash-ref hash word 0))))
hash)

(letrec
([l '(pure monkey made a salted monkey soup)])
(histogram (list->vector l)))

;'#hash((made . 1) (salted . 1) (soup . 1) (a . 1) (pure . 1) (monkey . 2))

所以 #Racket 还是很过程式的？(
从这个角度看，王垠在某个程度上还真是... 很灵性呢... 🙈

不过 Racket 其实是可函数式可过程式（
所以不能以语言论英雄

Racket 附赠的 IDE DrRacket 可以干多少种同类冷门语言来着

DrRacket 这个可以赞，Racket 的用途的确是广

这一点比 Haskell 强多了，Haskell 虽然是因为理论基础的原因（比 Scheme 那时候使用的抽象基础高级多了，不仅仅是 Lambda Calculus & Lexical Scoping 的那种函数式），但是“工业化”Haskell 基本没见到什么成效（

（就是…体积…🌚我说 Racket 装完怎么好几百 MB 又没了

体积都是小事情
Scheme 实现有好多的
Lisp 是家族最庞大的语言...

#Haskell emmm 稍微又看懂了一些，可是 eta 和 mu 就是很难懂啊！

newtype Reader t a = Reader { runReader :: t -> a }

instance Functor (Reader t) where
  fmap f (Reader g) = Reader (\x -> f (g x))

instance Applicative (Reader t) where
  pure = return
  Reader f <*> Reader g = Reader $ \x -> (f x) (g x)

instance Monad (Reader t) where
  return x = Reader (\_ -> x)
  Reader f >>= g = Reader (\x -> runReader (roll x) x)
    where
      roll = g . f

ask :: (t -> a) -> Reader t a
ask f = Reader (\x -> f x)

data Enviroment = Env { name :: String, price :: String }
  deriving (Eq, Show)

dogeR :: Reader Enviroment String
dogeR = do
  name <- ask name
  price <- ask price
  return (name ++ ": $" ++ price)

doge = runReader dogeR (Env "world" "-1")

其实是我又摸瞎写了一遍... 可是我花了很长时间，而且我并不能知道它是怎么工作的... 我得想想...

我使用 ApplicativeDo 可是这并不能证明我实现的 Applicative (Reader t) 是正确的... 无奈，Monad 排除类型上面 （η, μ） 的问题我好多了，可是 Applicative 我一些不懂

#JavaScript 以下很多东西都是从 《ES6 标准入门》这本峰老师开源的书上学到的

== 下面我来讲模板的东西：

我们来实现一个简单的模板编译系统。

比如说有模板：

<list>
  <% for (let { length: l, [0]: z } of ["abc", "def"]) { %>
  <li><%= '[' + l + ']: ' + z %>
  <% } %>
</list>

其实是可以弄成这种形式：

function template() {
  let result = ''
  result += '<list>'
  for (let { length: l, [0]: z } of ["abc", "def"]) {
    result += '<li>';
    result += '[' + l + ']: ' + z;
  }
  result += '</list>'
}

那么怎么弄呢，可以这样

先弄个上下文方便引用

function compiled() {
  let buffer = []
  const echo = (s) => buffer.append(s)

  ${template}

  return buffer.concat('')
}

... 这个有点长，简而言之就是正则替换 + 函数调用括号开闭，下周讲吧

== Promise 是怎么用的？

就是一个异步任务的表示，可以用 Promise.prototype.then 添加之后执行的函数
Promise.prototype.catch 添加错误捕捉器
Promise.prototype.done 把错误传递给上下文
Promise.resolve 可以直接解析出一个 promise，比如 Promise.resolve(1)

有三个状态：resolved 和 rejected 和 pending
然后任务可以调用 resolve 和 reject 改变状态

new Promise((resolve, reject) => {
  Thread.new(() => {
    sleep(500);
    resolve(1);
  }).start()
})

Promise.race 也是返回一个 Promise, 它组合所有参数 Promise，取第一个完成的子 Promise 的结果（所以叫 race）
Promise.all 是返回一个 Promise，它组合所有参数 Promise，不过这个 Promise 是所有子任务完成后才会 resolve

== async 函数是怎么用的？

就是 Promise 的语法糖，可以这么理解

async function doHello() {
  await waitTimeout(5000);
  console.log("Hello");
}

就是说

const doHello = () => waitTimeout(5000).then(_ => console.log("Hello"));

== Generator 函数是什么？

就是可以暂停执行交出执行权的函数

function* clock() {
  while (true) {
   yield 'Tick';
   yield 'Thock';
  }
}

function* coFib() {
  let a = 0
  let b = 1

  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

coFib.next()

// => {value: 0, done: false}

== 然后：为什么 Generator 函数可以实现 async？什么是 Thunk 函数？

你想想，yield 交出执行权后面的其实就可以作为某个异步任务的结果的 handler 啊！

Couroutine 的 next 方法可以给 yield 表达式传递值

function* goo() {
  let a = yield 2;
  console.log(a);
}

let g = goo();
g.next(3).value; // 2
g.next() //3

比如 yield readFile('a')

之后，只要我们把异步任务的 next() 函数串到后面的 Generator 的 next 方法上就好了，这就是 Promise 和 Generator 的结合...

function *readFileAndPrint() {
   let f = yield readFile('f');
   console.log(f);
}

其实是要在 readFile 完成后，用 next(readFileResult) 令这个 Generator 函数重新获得执行权，进行下面的 console.log 操作，这就是所谓的 async function
— Generator 函数加上自动执行器，这个执行器给 yield 到的 Thenable 对象添加回调，而回调函数利用 Generator 的 next 方法将执行权转交 async 函数的逻辑，实现『断断续续』地异步执行

== Thunk 函数又是什么？

Thunk 函数也是得出 Thenable 的一种工具

readFileThunk = path => callback => readFile (path, callabck)

这样我们就可以在 Generator 里 yield 一个接受回调函数的函数，也就是 thenable，而不是 Promise 对象（使用 then 方法指定回调）了

let readHello = readFileThunk("Hello.txt")
readHello /* then */ (x => console.log(x.content))

然后我就可以去写...
+ 默写 C# BitMap 反色算法
+ ES6 重写 sm.ms js 库（虽然原来也有用 ES6 特性）

我熟悉了这些抽象以后会再写一遍...

简而言之，就是 Task、Result、ResultHandler、Stoppable...

我这么做了，没有覆写的有 Cancelled 和 Progress，当然也有 kotlin.Any 的 equals toString hashCode