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

https://gist.github.com/duangsuse/dfc532a16f547459bcf3f4f8d922d849 #code

接下来 duangsuse 想写完 C# 的 BitMap reverseclor 后去写 Android 的 SharePreferenceProxy...

啊，现在感觉压力小了好多，看来默写一部分也是有参考价值的... [1]

[1]: duangsuse 有时候（在提到某些应用和诸如讨论函数式编程和某些与应用编程无关的东西时）会有将要被应用层的开发者们喷的感觉，尤其是他看到比较“复杂”的应用的时候....
这种感觉会在他重写掉这种应用的一部分之后得到缓解。

#CSharp 虽然 C# 可以相当好看，但是我很菜不会写 CSharp，不过这里还是有一个好玩一点的东西，很可惜 CSharp 没有类似 findViewById 那样的... 就更好了（当然，现在更流行使用 ButterKnife BindView，但都不如 Qt Widgets 和 Kotlin Anko 直接拿到 Widget 实例）

这就是 #CSharp 的箭头 Constructor 简写和 Property、IEnumerator 状态机

C# 好看起来真的能把 Java 和 Kotlin 都比下去，可是我还不会 C#...

看起来 Mono 还真是挺好用的呢