星雨之夜

从递归到 Y 组合子

Tue, 29 Jan 2019 16:30:41 GMT

停机问题

我们再来回顾一下停机问题：

是否存在一个函数 P，对于任意输入的函数 w，能够判断 w 会在有限时间内结束或者死循环。

通过前文的论述，我们已经知道这样的函数 P 是不存在的。由此可知，某些函数存在可以用语言描述却无法被程序定义的情况，以 Scheme 语言为例，即无法用 (define ...) 给函数命名。

递归

我们知道递归在 Scheme 中重要性是处在第一序列的。「The Little Schemer」书里，几乎所有函数都是围绕着递归思想来创建的。下面来看一个用于获取列表 l 的长度的例子：

(define length
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))

它定义了 length 这个函数名称并用其进行递归操作。

如果这时候告诉你，(define ...) 不能用了，那么还能有什么方法可以表示出 length 函数呢？答案是有的，不过得让我们一步步来接近它。

高阶函数

高阶函数的一个形式是：接受一个函数作为参数，返回另一个函数。在上述例子中，我们可以引入一个高阶函数，把函数 length 作为参数传入：

(lambda (length)
  (lambda (l)
    (cond
     	((null? l) 0)
     	(else (add1 (length (cdr l)))))))

显然它返回的也是 length 函数本身，而且没有再用到 (define ...)。因为这个高阶函数创建了 length 函数（make length），所以干脆就叫它 mk-length。

事情看起来已经符合我们的要求了，接下来似乎只要

(mk-length length)

就能得到 length 函数。不过传入的 length 参数依旧需要通过 mk-length 来生成，也就是：

(mk-length (mk-length length))

可以预见接下来还会有：

(mk-length (mk-length (mk-length length)))

(mk-length
  (mk-length
    (mk-length
      ...)))

这样下去就进入了无限循环。让我们先回到 (mk-length length)。

从头开始

上面 length 被不停创建的过程触发了无限递归，要解决这个问题，我们来做一个神奇的替换。

(define eternity
  (lambda (x)
    (eternity x)))

eternity 是我们之前创建出来的一个最简单的偏函数，并且也是无限递归的。我们用它来替换 length，代入 (mk-length eternity) 并展开：

((lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l)))))))
 eternity)

再创建一个高阶函数，将 mk-length 本身作为参数提取出来：

((lambda (mk-length)
   (mk-length eternity))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l))))))))

那么上面这个函数是否已经创建出了 length 函数呢，我们代入具体的列表 l 来检验。

当 l 是空列表时，进入 (null? l) 分支，返回值是 0，正确。

当 l 是 (a) 这样的非空列表时，则进入 else 分支，但是 (etertiny (quote ())) 并不会返回值，函数也就不会返回正确的答案。

这个函数看起来只能计算空列表的长度，称之为 length0 似乎更加贴切。

(define length0 (mk-length eternity))

接下来我们可以写出 length1，它可以计算长度不超过 1 的列表：

((lambda (mk-length)
   (mk-length length0))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l))))))))

展开：

((lambda (mk-length)
   (mk-length
     (mk-length eternity)))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l))))))))

可以写出 length2 了吗？当然：

((lambda (mk-length)
   (mk-length
     (mk-length
       (mk-length eternity))))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l))))))))

它可以计算长度不大于 2 的列表。lengthN 呢？

((lambda (mk-length)
   (mk-length
     (mk-length
       (mk-length
         ...))))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l))))))))

要写 N 个 mk-length 了。

分析上面的推导过程可知，我们现在还无法定义一个通用的 length 函数，使得它能够计算任意列表的长度。从另一个角度考虑，如果在上面的函数形式中，我们能够写出足够多个 mk-length ，那么就能计算任意列表的长度了。但是“足够多”太抽象，不同列表所要求的个数有所不同，对于一个程序或者函数来讲，这样是写不出来的。

我算我自己

我们再来看看 mk-length，因为它的参数是一个函数，所以理论上可以调用任意函数。我们把 mk-length 传给自己试试：

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l))))))))

length 作为入参可以用任意字符表示，甚至是 mk-length：

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (mk-length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (mk-length (cdr l))))))))

现在我们得出了什么呢？当传入非空列表时，else 分支的 mk-length 接收一个列表作为参数，但是它实际上需要的参数是函数，所以最后并不会计算出值，这就和 length0 一样了。同时也表明我们将 mk-length 传给自己其实没有改变整个函数的意义。

如果我们用这个参数 mk-length 继续创建递归，就用 eternity 好了：

; 函数一
((lambda (mk-length)
   (mk-length mk-length))
 (lambda (mk-length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1
               ((mk-length eternity)
                  (cdr l))))))))

代入列表 l 看看，l 这里是 (apple)：

; 第一步
(((lambda (mk-length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1
                ((mk-length eternity)
                   (cdr l)))))))
  (lambda (mk-length) ; 代入展开
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1
                ((mk-length eternity)
                   (cdr l))))))))
 l)

; 第二步
((lambda (l)
   (cond
     ((null? l) 0)
     (else (add1 (((lambda (mk-length)
                     (lambda (l)
                       (cond
                         ((null? l) 0)
                         (else (add1
                                 ((mk-length eternity)
                                    (cdr l)))))))
                   eternity) ; 代入展开
                  (cdr l))))))
 l)

; 第三步
((lambda (l)
   (cond
     ((null? l) 0)
     (else (add1 ((lambda (l)
                    (cond
                      ((null? l) 0)
                      (else (add1
                              ((eternity eternity)
                                 (cdr l))))))
                  (cdr l)))))) ; 代入展开，这里 (cdr l) 是 (quote ())，返回 0
 l)

现在能够计算长度是 1 的列表了。那长度为 2 的呢？假设这时 l 是 (apple banana)，前三步是和上面一样的，最后可以简化成：

(add1 (add1 ((eternity eternity) (quote ()))))

其中 (eternity eternity) 在无限递归，上述表达式没有返回值，所以我们算不出长度为 2 的列表。那么函数一其实就是 length1。问题来了，有没有什么办法可以让 (eternity eternity) 这个位置的递归继续下去，这样我们好像就可以计算任意长度的列表了。

解决方案还是和这一节最开始用的相同方法，我们让 mk-length 来调用 mk-length：

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (mk-length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1
               ((mk-length mk-length)
                  (cdr l))))))))

这么做的目的是在递归即将结束的时候，又将 mk-length 传递给自身，确保递归的不断进行。

有点激动呀，我们终于能够抛弃 (define ...)，仅用 lambda 表达式就写出 length 函数了 🥳 不过先等一下，在为胜利欢呼之前，我们来验证一下函数的正确性。

终极答案

首先我们用高阶函数把 (mk-length mk-length) 语句提取出来，让函数更加清晰：

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (mk-length)
   ((lambda (length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (length (cdr l)))))))
    (mk-length mk-length))))

第 4 到 8 行长得就很像一开始的 mk-length，这么一来就舒服了。之后当然是用具体的列表来测试啦，依旧借用 (apple)。要计算 (length (quote (apple))) 的值需要先展开 length 也就是上面这个函数，我们来试试吧。

((lambda (mk-length)
   ((lambda (length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (length (cdr l)))))))
    (mk-length mk-length)))
 (lambda (mk-length) ; 代入展开
   ((lambda (length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (length (cdr l)))))))
    (mk-length mk-length))))

((lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l)))))))
 ((lambda (mk-length)
    ((lambda (length)
       (lambda (l)
         (cond
           ((null? l) 0)
           (else (add1 (length (cdr l)))))))
     (mk-length mk-length)))
  (lambda (mk-length) ; 代入展开
    ((lambda (length)
       (lambda (l)
         (cond
           ((null? l) 0)
           (else (add1 (length (cdr l)))))))
     (mk-length mk-length)))))

((lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l)))))))
 ((lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l)))))))
  ((lambda (mk-length)
     ((lambda (length)
        (lambda (l)
          (cond
            ((null? l) 0)
            (else (add1 (length (cdr l)))))))
      (mk-length mk-length)))
   (lambda (mk-length) ; 代入展开...
     ((lambda (length)
        (lambda (l)
          (cond
            ((null? l) 0)
            (else (add1 (length (cdr l)))))))
      (mk-length mk-length))))))

咦等等，这么一级级展开完全没有尽头，我们只是不停地把 mk-length 应用到它自己身上，周而复始。(mk-length mk-length) 本来期待它返回一个函数的，现在再也返回不了了。这可怎么办，胜利道路严重受阻。

不要方，我们还有一个武器——惰性求值，它的思想简单来说就是使表达式在被用到的时候才求值。在我们的需求里面就是对 (mk-length mk-length) 惰性求值，前面的运算里面不对它进行展开。

如何做？我们考虑到 (mk-length mk-length) 返回的函数在理论条件下就是 length，它是一个单参数函数。那么我们构造一个单参数函数，它可以做到惰性求值：

(lambda (x)
  ((mk-length mk-length) x))

Lambda 演算中的第三条 η-变换规则规定到：对于任一给定的参数，当且仅当两个函数得到的结果都一致，则它们将被视同为一个函数。即如果对于给定的 l，((mk-length mk-length) l) 和 ((lambda (x) ((mk-length mk-length) x)) l) 的值都相同，那么就说这两个函数是等价的。显然他们就是同一个函数。那么做完替换之后长这样：

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (mk-length)
   ((lambda (length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (length (cdr l)))))))
    (lambda (x)
      ((mk-length mk-length) x)))))

我们再构建一个高阶函数，移出第 4 到 8 行长得像 mk-length 的部分，作为参数：

((lambda (le)
   ((lambda (mk-length)
      (mk-length mk-length))
    (lambda (mk-length)
      (le (lambda (x)
            ((mk-length mk-length) x))))))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l))))))))

🎉 大功告成！以上就是我们不用 (define ...) 而写出的 length 最终版本。不容易啊。

Y 组合子

我们把上面函数调用 mk-length 的逻辑部分剥离出来：

(lambda (le)
  ((lambda (mk-length)
     (mk-length mk-length))
   (lambda (mk-length)
     (le (lambda (x)
           ((mk-length mk-length) x))))))

简化一下：

(lambda (le)
  ((lambda (f) (f f))
   (lambda (f)
     (le (lambda (x) ((f f) x))))))

这玩意儿就叫应用序 Y 组合子（applicative-order Y combinator）！

仔细体会整个过程，在不给函数命名的情况下，我们最终却实现了这个递归函数。实际上正是 Y 组合子做了这件极其伟大的事情——实现递归。

补充：不动点组合子

这里我们先引入不动点的概念：对于函数 f，如果存在变量 x，有 f(x) = x，此时就说 x 是函数 f 的不动点。

我们来看看 mk-length 的不动点 fixed-point 是什么。

(define fixed-point
  (mk-length fixed-point))

那么可以替换函数体中的 fixed-point 为 (mk-length fixed-point)：

(define fixed-point
  (mk-length
    (mk-length fixed-point)))

(define fixed-point
  (mk-length
    (mk-length
      (mk-length fixed-point))))

(define fixed-point
  (mk-length
    (mk-length
      (mk-length
        ...))))

看上去很眼熟对不对？所以 mk-length 的不动点就是我们想要的 length。于是求 length 的问题就转化为：有没有这样一个函数 calc-fixed-point，代入参数 mk-length，然后得到 mk-length 的不动点：

(calc-fixed-point mk-length) = length

又是一个眼熟的表达式，calc-fixed-point 看起来就是我们上面所得到的 Y 组合子，它可以计算参数的不动点。所以有时它又被称为不动点组合子。

关于 Lambda 演算、组合子、由不动点推导 Y 组合子等知识点，本文暂不作讨论。我光是看明白「The Little Schemer」第九章里推导 Y 组合子的过程，头就已经大了好几圈，头发也多掉了好几万根，就像书里说得那样。文章也无法避免由主观臆断而产生的概念性或者推导上的错误，欢迎指正。

参考链接

「The Little Schemer：递归与函数式的奥妙」第 9 章
The Y Combinator
Little Schemer: why wrap (mk-length mk-length) into a function?
十分钟速通 Y Combinator
scheme 下的停机问题和 Y 组合子
Y 不动点组合子用在哪里？
Lambda 演算 - 维基百科
不动点组合子 - 维基百科

The Little Schemer 知识点整理（九）：……周而复始……

Thu, 24 Jan 2019 16:30:16 GMT

自定义函数

(looking a lat)

定义：在一个 lat 中查找有没有 a，但按照如下规律：

假设 a 是 caviar，lat 是 (6 2 4 caviar 5 7 3)，那么列表的第 1 个元素是 6，第 6 个元素是 7，第 7 个元素是 3，第 3 个元素是 4，第 4 个元素是 caviar，它不是数字了，与 a 相同，那么函数结果就是 #t。

实现：

(define looking
  (lambda (a lat)
    (keep-looking a (pick 1 lat) lat)))

(define keep-looking
  (lambda (a sorn lat)
    (cond
      ((number? sorn)
        (keep-looking a (pick sorn lat) lat))
      (else (eq? sorn a)))))

sorn 代表 symbol or number。

对比之前所学的递归，可以发现这里的 keep-looking 并没有对 lat 的某部分进行递归调用。我们把这样的递归称之为“非一般性”递归。那么这样的递归还有什么特点呢？

继续假设 a 还是 caviar，但 lat 变成 (7 2 4 7 5 6 3)，可以看到查询进程永远不会停下来。我们把 looking 这样的函数称为部分函数（Patial Function），以前所接触的那些函数都叫全函数（Total Function）。

(eternity x)

这里定义了一个最简单的部分函数 eternity，它并未完成任何目标，只是传入参数 x，不停递归调用。

(define eternity
  (lambda (x)
    (eternity x)))

(shift pair)

定义：参数 pair 的第一个元素也是 pair，将这个 pair 的第二个元素移进参数 pair 的第二个元素中，以此构建一个新的 pair。

实现：

(define shift
  (lambda (pair)
    (build (first (first pair))
           (build (second (first pair))
                  (second pair)))))

(align pora)

align 和 keep-looking 一样，在第二个条件中，(shift pora) 改变了 align 的参数，它不一定是 pora 的一部分，无法保证能够接近最终目标。其实这是违反了第七诫。

(define align
  (lambda (pora)
    (cond
      ((atom? pora) pora)
      ((a-pair? (first pora))
        (align (shift pora)))
      (else (build (first pora)
                   (align (second pora)))))))

(length* pora)

定义：计算 pora 中的原子个数。

实现：

(define length*
  (lambda (pora)
    (cond
      ((atom? pora) 1)
      (else
        (plus (length* (first pora))
              (length* (second pora)))))))

(shuffle pora)

类似于 align，用 revpair 替代 shift。

(define shuffle
  (lambda (pora)
    (cond
      ((atom? pora) pora)
      ((a-pair? (first pora))
        (shuffle (revpair pora)))
      (else (build (first pora)
                   (shuffle (second pora)))))))

假设 pora 是 ((a b) (c d))，那么 (shuffle pora) 递归不会停止，所以它是一个部分函数。

(A n m)

定义：参考阿克曼函数。

实现：

(define A
  (lambda (n m)
    (cond
      ((zero? n) (add1 m))
      ((zero? m) (A (sub1 n) 1))
      (else (A (sub1 n)
               (A n (sub1 m)))))))

这是一个全函数，但是不是所有值都能轻易计算出来，比如 (A 4 3)。

停机问题

经历了这么多全函数和部分函数的讨论，我们设计一个函数，用来判断某些函数：针对每个参数，是否返回一个值。形式如下：

(define will-stop?
  (lambda (f)
    ...))

它总是返回 #t 或者 #f，所以是一个全函数。接下来代入几个函数，逐个分析他们是不是会 stop？函数的参数都用空列表来代替，这样最简单。

length

(length (quote ())) 是 0，这时 will-stop? length 为 #t。
eternity

(eternity (quote ())) 不会返回值，根本停不下来，这时 will-stop? length 显然是 #f。
last-try

定义 last-try：
```
(define last-try
  (lambda (x)
    (and (will-stop? last-try)
        (eternity x))))
```
(last-try (quote ())) 的值也就是 (and (will-stop? last-try) (eternity (quote ()))) 的值。考虑以下两种情况：
- (will-stop? last-try) 是 #f，表示 last-try 停不下来，则：
  1. (and (will-stop? last-try) (eternity (quote ()))) = #f；
  2. (last-try (quote ())) = #f，表示 last-try 能够停下来。嗯？矛盾。
- (will-stop? last-try) 是 #t，表示 last-try 能够停下来，则：
  1. (and (will-stop? last-try) (eternity (quote ())))，后面的 eternity 停不下来，整体也停不下来啊；
  2. 于是 (last-try (quote ())) 也停不下来。嗯？？？也矛盾了。

所以对于 will-stop?，如果我们能够定义它，那么它必然会生成 #t 或 #f；但是上面的例子告诉我们有时这是做不到的。要定义清楚 will-stop? 就必须意味着它无法被定义。说人话就是我们写不出 will-stop? 这样的函数。详见停机问题。

Y 组合子

本章的余下内容在构造 Y 组合子，即大名鼎鼎的 Y Combinator。我看了好几遍，查了一堆资料，才懂了个大概，感觉值得单独写一篇文章来详细叙述，把「The Little Schemer」第九章的论述方法用自己的理解再写一遍。

The Little Schemer 知识点整理（八）：Lambda 终结者

Wed, 09 Jan 2019 13:12:12 GMT

准备知识

函数可以返回原子和列表；它也能返回一个函数。
你可能听说过函数“柯里化”。
col 是 collector 的缩写，有时又叫 continuation。

Scheme 十诫之第九诫

用函数来抽象通用模式。

Scheme 十诫之第十诫

构建函数，一次收集多个值。

自定义函数

(rember-f test? a l)

定义：函数版本的 rember。test? 至少有以下几种情况：

test? 是 =
test? 是 eq?
test? 是 equal?

实现：

(define rember-f
  (lambda (test? a l)
    (cond
      ((null? l) (quote ()))
      ((test? (car l) a) (cdr l))
      (else (cons (car l)
                  (rember-f test? a (cdr l)))))))

如果返回一个函数：

(define rember-f
  (lambda (test?)
    (lambda (a l)
      (cond
        ((null? l) (quote ()))
        ((test? (car l) a) (cdr l))
        (else (cons (car l)
                    ((rember-f test?) a (cdr l))))))))

用法就变成 ((rember-f test?) a l)。

(eq?-c a)

定义：其返回一个函数，这个函数用于比较原子 x 与 a 是否相同。

实现：

(define eq?-c
  (lambda (a)
    (lambda (x)
      (eq? x a))))

((insertL-f test?) new old l)

定义：按照 rember 转换 rember-f 的思路转换 insertL。

实现：

(define insertL-f
  (lambda (test?)
    (lambda (new old l)
      (cond
        ((null? l) (quote ()))
        ((test? (car l) old)
          (cons new (cons old (cdr l))))
        (else (cons (car l)
                    ((insertL-f test?) new old (cdr l))))))))

((insertR-f test?) new old l)

定义：按照 rember 转换 rember-f 的思路转换 insertR。

实现：

(define insertR-f
  (lambda (test?)
    (lambda (new old l)
      (cond
        ((null? l) (quote ()))
        ((test? (cdr l) old)
          (cons old (cons new (cdr l))))
        (else (cons (cdr l)
                    ((insertR-f test?) new old (cdr l))))))))

比较上述两个函数的差异，发现在于中间的某一行。于是我们引入以下两个函数。

(seqL new old l)

定义：cons 第二个参数到第三个参数上，得到一个结果，然后再 cons 第一个参数到这个结果上。

实现：

(define seqL
  (lambda (new old l)
    (cons new (cons old l))))

(seqR new old l)

定义：cons 第一个参数到第三个参数上，得到一个结果，然后再 cons 第二个参数到这个结果上。

实现：

(define seqR
  (lambda (new old l)
    (cons old (cons new l))))

((insert-g seq) new old l)

定义：引入 insert-g，可以表示 insertL 或者 insertR。这里 seq 是 seqL 或者 seqR。

(define insert-g
  (lambda (seq)
    (lambda (new old l)
      (cond
        ((null? l) (quote ()))
        ((eq? (car l) old)
          (seq new old (cdr l)))
        (else (cons (cdr l)
                    ((insert-g seq) new old (cdr l))))))))

那么我们定义 insertL 可以这样做：

(define insertL (insert-g seqL))

同样的，insertR：

(define insertR (insert-g seqR))

但是其实不需要单独定义函数，我们可以直接传递整个定义：

(define insertL
  (insert-g
    (lambda (new old l)
      (cons new (cons old l)))))

考虑以前定义过的 subst，也可以这么写：

(define subst
  (insert-g
    (lambda (new old l)
      (cons new l))))

(atom-to-function x)

定义：我们提取 value （第六章）的公共部分，这个函数相当于数学符号的 parser，根据读取到的不同原子（+×↑）来定义运算方法。

实现：

(define atom-to-function
  (lambda (x)
    (cond
      ((eq? x (quote +)) plus)
      ((eq? x (quote ×)) ×)
      (else ↑))))

那么我们的 value 函数可以写成：

(define value
  (lambda (nexp)
    (cond
      ((atom? nexp) nexp)
      (else
        ((atom-to-function (operator nexp))
          (value (1st-sub-exp nexp))
          (value (2nd-sub-exp nexp)))))))

以下函数在实现功能的同时，又用 col 收集了其他我们想要的值。

(multirember&co a lat col)

定义：查找 lat 的每个原子，判断该原子是否等于 a，否的话那些原子被收集进 ls1 中，是的话被收集进 ls2 中。最后计算 (col ls1 ls2) 的值。

实现：

(define multirember&co
  (lambda (a lat col)
    (cond
      ((null? lat)
        (col (quote ()) (quote ())))
      ((eq? (car lat) a)
        (multirember&co a (cdr lat)
          (lambda (newlat seen)
            (col newlat (cons (car lat) seen)))))
      (else
        (multirember&co a (cdr lat)
          (lambda (newlat seen)
            (col (cons (car lat) newlat) seen)))))))

(multiinsertLR&co new oldL oldR lat col)

定义：将 new 插入到 lat 的 oldL 的左边和 oldR 的右边，同时记录左右分别插入了多少次。

实现：

(define multiinsertLR&co
  (lambda (new oldL oldR lat col)
    (cond
      ((null? lat)
        (col (quote ()) 0 0))
      ((eq? (car lat) oldL)
        (multiinsertLR&co new oldL oldR (cdr lat)
          (lambda (newlat L R)
            (col (cons new (cons oldL newlat)) (add1 L) R))))
      ((eq? (car lat) oldR)
        (multiinsertLR&co new oldL oldR (cdr lat)
          (lambda (newlat L R)
            (col (cons oldR (cons new newlat)) L (add1 R)))))
      (else (multiinsertLR&co new oldL oldR (cdr lat)
        (lambda (newlat L R)
          (col (cons (car lat) newlat) L R)))))))

(evens-only* l)

定义：去除 l 中所有的奇数。

我们先定义判断偶数的函数 even?：

(define even?
  (lambda (n)
    (= (× (÷ n 2) 2) n)))

(define evens-only*
  (lambda (l)
    (cond
      ((null? l) (quote ()))
      ((atom? (car l))
        (cond
          ((even? (car l))
            (cons (car l)
                  (evens-only* (cdr l))))
          (else (evens-only* (cdr l)))))
      (else (cons (evens-only* (car l))
                  (evens-only* (cdr l)))))))

接下来试着写一个 evens-only*&co 函数，其从一个列表中移除所有奇数项，以构建一个偶数项的嵌套列表，同时求出该列表所有偶数项的乘积和奇数项的和。

(define evens-only*&co
  (lambda (l col)
    (cond
      ((null? l) (col (quote ()) 1 0))
      ((atom? (car l))
        (cond
          ((even? (car l))
            (evens-only*&co (cdr l)
              (lambda (newl p s)
                (col (cons (car l) newl) (× (car l) p) s))))
          (else (evens-only*&co (cdr l)
            (lambda (newl p s)
              (col newl p (plus (car l) s)))))))
      (else (evens-only*&co (car l) ...)))))

可以发现 (evens-only*&co (cdr l) ...) 的 collector 很好写，但是 (evens-only*&co (car l) ...) 的 collector 应该怎么写呢？

首先这个 collector 要通过 evens-only*&co 访问 l 的 cdr，并收集偶数项，偶数项乘积和奇数项之和，可以这么定义：

(lambda (al ap as)
  (evens-only*&co (cdr l)
    ...))

然后接下来的一个 collector 要做的是，把 (cdr l) 和 (car l) 所收集的值——偶数项、偶数项乘积、奇数项之和——cons、累乘、累加：

(lambda (al ap as)
  (evens-only*&co (cdr l)
    (lambda (dl dp ds)
      (col (cons al dl)
           (× ap dp)
           (plus as ds)))))

这就是上面 evens-only*&co 所缺失的定义了。

The Little Schemer 知识点整理（七）：朋友及关系

Sat, 05 Jan 2019 15:09:54 GMT

准备知识

set：集合，注意区别于 collection，原子组成的列表，其中不包含重复原子。
pair：其中的两个元素是含义不同但是相关的对象。
构建 pair：(cons x1 (cons x2 (quote ())))。

构建 pair 的表示方式：

(define first
 (lambda (p)
   (car p)))

(define second
 (lambda (p)
   (car (cdr p))))

(define build
 (lambda (s1 s2)
   (cons s1 (cons s2 (quote ())))))

rel：由 pair 组成的 set。

自定义函数

(set? lat)

定义：判断一个 lat 是不是一个集合（set），集合里不含相同原子。

实现：

(define set?
  (lambda (lat)
    (cond
      ((null? lat) #t)
      ((member? (car lat) (cdr lat)) #f)
      (else (set? (cdr lat))))))

注意 member?，第二章就已经实现了这个函数。

(makeset lat)

定义：把一个 lat 转化为 set（原子去重）。

实现：

(define makeset
  (lambda (lat)
    (cond
      ((null? lat) (quote ()))
      ((member? (car lat) (cdr lat))
        (makeset (cdr lat)))
      (else
        (cons (car lat)
              (makeset (cdr lat)))))))

我们使用 multirember 函数重写 makeset：

(define makeset
  (lambda (lat)
    (cond
      ((null? lat) (quote ()))
      (else
        (cons (car lat)
          (makeset
            (multirember (car lat)
              (cdr lat))))))))

与第一次写出的函数不同的是，这次我们首先移除了剩余列表中的重复原子，最终的打印结果也更加符合直觉。

(subset? set1 set2)

定义：判断 set1 是不是 set2 的子集。

实现：

(define subset?
  (lambda (set1 set2)
    (cond
      ((null? set1) #t)
      ((member? (car set1) set2)
        (subset? (cdr set1) set2))
      (else #f))))

改用 and：

(define subset?
  (lambda (set1 set2)
    (cond
      ((null? set1) #t)
      (else
        (and (member? (car set1) set2)
             (subset? (cdr set1) set2))))))

(eqset? set1 set2)

定义：判断 set1 和 set2 是否相同。

实现：

(define eqset?
  (lambda (set1 set2)
    (cond
      ((subset? set1 set2)
        (subset? set2 set1))
      (else #f))))

用 and 简化：

(define eqset?
  (lambda (set1 set2)
    (and (subset? set1 set2)
         (subset? set2 set1))))

(intersect? set1 set2)

定义：判断 set1 中是否至少有一个原子也在 set2 中。

实现：

(define intersect?
  (lambda (set1 set2)
    (cond
      ((null? set1) #f)
      ((member? (car set1) set2) #t)
      (else (intersect? (cdr set1) set2)))))

改用 or：

(define intersect?
  (lambda (set1 set2)
    (cond
      ((null? set1) #f)
      (else
        (or (member? (car set1) set2)
            (intersect? (cdr set1) set2))))))

对比一下 subset? 和 intersect?。

(intersect set1 set2)

定义：从 set2 中取出 set1 中包含的原子的列表。

实现：

(define intersect
  (lambda (set1 set2)
    (cond
      ((null? set1) (quote ()))
      ((member? (car set1) set2)
        (cons (car set1)
              (intersect (cdr set1) set2)))
      (else (intersect (cdr set1) set2)))))

(union set1 set2)

定义：merge 两个 set。（不知道怎么表述了 😂）

实现：

(define union
  (lambda (set1 set2)
    (cond
      ((null? set1) set2)
      ((member? (car set1) set2)
        (union (cdr set1) set2))
      (else (cons (car set1)
                  (union (cdr set1) set2))))))

只改动一个条件 ((null? set1) (quote ()))，这个函数回变成什么样呢？

(define xxx
  (lambda (set1 set2)
    (cond
      ((null? set1) (quote ()))
      ((member? (car set1) set2)
        (xxx (cdr set1) set2))
      (else (cons (car set1)
                  (xxx (cdr set1) set2))))))

xxx 函数返回只存在于 set1 却不存在于 set2 中的原子列表。

(intersectall l-set)

定义：l-set 是由一组列表组成的非空列表，该函数取出这些列表中的相同原子，返回这些原子组成的新列表。

实现：

(define intersectall
  (lambda (l-set)
    (cond
      ((null? (car l-set)) (car l-set))
      (else (intersect (car l-set)
                       (intersectall (cdr l-set)))))))

(a-pair? x)

定义：判断 S-表达式 x 是不是一个 pair（仅有两个 S-表达式组成的列表）。

实现：

(define a-pair
  (lambda (x)
    (cond
      ((atom? x) #f)
      ((null? x) #f)
      ((null? (cdr x)) #f)
      ((null? (cdr (cdr x))) #t)
      (else #f))))

无知的分割线

本章接下来的一部分有点没看懂，不是很明白这里介绍的函数和全函数的概念。所以只写下自己所理解的。

(fun? rel)

定义：判断一个 rel 中，任一 pair 的第一个元素都与其他 pair 的第一个元素是否相同。或者可以表述为，判断一个 rel 中由每个 pair 的第一个元素组成的新列表是否为一个 set。我们把这样的 rel 称之为函数（？）。

实现：

(define fun?
  (lambda (rel)
    (set? (firsts rel))))

firsts 的定义可以回顾一下第三章。

(revrel rel)

定义：交换一个 rel 中每个 pair 的两个元素。

实现：

(define revrel
  (lambda (rel)
    (cond
      ((null? rel) (quote ()))
      (else (cons
              (build (first (car rel))
                     (second (car rel)))
              (revrel (cdr rel)))))))

(revpair pair)

定义：交换一个 pair 中的两个元素。

实现：

(define revpair
  (lambda (pair)
    (build (second pair) (first pair))))

那么 revrel 函数就可以表述为以下形式，大大提升了可读性：

(define revrel
  (lambda (rel)
    (cond
      ((null? rel) (quote ()))
      (else (cons
              (revpair (car rel))
              (revrel (cdr rel)))))))

(fullfun? fun)

定义：一个 rel 除了是 fun 以外，它的每个 pair 的第二元素也与其他 pair 的第二个元素不同。我们把这样的 fun 称之为全函数（？）。它是一一对应的。

实现：

(define fullfun?
  (lambda (fun)
    (set? (seconds fun))))

我们可以像实现 firsts 那样实现 seconds 函数。当然也可以用上面已经引入的函数：

(define fullfun?
  (lambda (fun)
    (fun? (revrel fun))))

🐱 写到现在觉得书比自己整理的好看太多了，这本书一点也不枯燥 🥰

The Little Schemer 知识点整理（六）：如影随形

Sat, 29 Dec 2018 15:32:25 GMT

准备知识

算术表达式

它要么是一个原子（包括数字），要么是用 +×↑ 连接起来的两个算术表达式。
算术表达式的表示方式
- 中缀：(3 + 4)
- 后缀：(3 4 +)
- 前缀：(+ 3 4)
- 前缀：(+ (× 3 6) (↑ 8 2))
表示法

数字也是某种表示法，比如阿拉伯表示法 4。我们也可以用 (() () () ()) 来表示。

Scheme 十诫之第七诫

对具有相同性质的 subparts 进行递归调用：

列表的子列表
算术表达式的子表达式

Scheme 十诫之第八诫

~~八戒，为师。。。~~

使用辅助函数来抽象表达方式。

自定义函数

(numbered? aexp)

定义：用于判断一个算术表达式的表示方式中，是否除了 +×↑ 之外，只包含数字。

实现：

(define numbered?
  (lambda (aexp)
    (cond
      ((atom? aexp) (number? aexp))
      (else
        (and (numbered? (car aexp))
             (numbered? (car (cdr (cdr aexp)))))))))

(value nexp)

定义：返回可计数算术表达式（中缀）的一般性值。

实现：

(define value
  (lambda (nexp)
    (cond
      ((atom? nexp) nexp)
      ((eq? (car (car nexp)) (quote +))
        (plus (value (car nexp))
              (value (car (cdr (cdr nexp))))))
      ((eq? (car (car nexp)) (quote ×))
        (× (value (car nexp))
           (value (car (cdr (cdr nexp))))))
      (else
        (↑ (value (car nexp))
           (value (car (cdr (cdr nexp)))))))))

如果是前缀表达式的话：

(define value
  (lambda (nexp)
    (cond
      ((atom? nexp) nexp)
      ((eq? (car nexp) (quote +))
        (plus (value (car (cdr nexp)))
              (value (car (cdr (cdr nexp))))))
      ((eq? (car nexp) (quote ×))
        (× (value (car (cdr nexp)))
           (value (car (cdr (cdr nexp))))))
      (else
        (↑ (value (car (cdr nexp)))
           (value (car (cdr (cdr nexp)))))))))

(1st-sub-exp aexp)

定义：一个算术表达式（前缀）的表示方式中的第一个子表达式。

实现：（可省略 cond 和 else，因为只有一个问题）

(define 1st-sub-exp
  (lambda (aexp)
    (car (cdr aexp))))

(2nd-sub-exp aexp)

定义：一个算术表达式（前缀）的表示方式中的第二个子表达式。

实现：

(define 2nd-sub-exp
  (lambda (aexp)
    (car (cdr (cdr aexp)))))

抽象 value 函数

我们把 (car nexp) 替换成 (operator nexp)：

(define operator
  (lambda (aexp)
    (car aexp)))

那么 value 函数可以重写为：

(define value
  (lambda (nexp)
    (cond
      ((atom? nexp) nexp)
      ((eq? (operator nexp) (quote +))
        (plus (value (1st-sub-exp nexp))
              (value (2nd-sub-exp nexp))))
      ((eq? (operator nexp) (quote ×))
        (× (value (1st-sub-exp nexp))
           (value (2nd-sub-exp nexp))))
      (else
        (↑ (value (1st-sub-exp nexp))
           (value (2nd-sub-exp nexp)))))))

调整 1st-sub-exp 和 operator 就可以表示中缀算术表达式：

(define 1st-sub-exp
  (lambda (aexp)
    (car aexp)))

(define operator
  (lambda (aexp)
    (car (cdr aexp))))

这里，1st-sub-exp，2nd-sub-exp 和 operator 都是辅助函数。

回顾 lat? 函数

(define lat?
  (lambda (l)
    (cond
      ((null? l) #t)
      ((atom? (car l)) (lat? (cdr l)))
      (else #f))))

如果 0 表示为 ()，1 是 (())，2 是 (() ())，以此类推。

当 l 是 (1 2 3)，lat? l 显然是 #t。但是如果把数字用上述表示法表示，那 lat? l 的值显然是 #f，与实际不符。所以使用辅助函数来抽象的时候需要注意这类问题。

The Little Schemer 知识点整理（五）：我得天！都是星星

Thu, 13 Dec 2018 18:11:10 GMT

准备知识

所有 * 函数所处理的列表，都满足以下情况中的一种：
- 空列表。
- 一个原子 cons 在一个列表上。
- 一个列表 cons 在另一个列表上。
(and ...) 第一个参数为 false 则直接返回 false；(or ...) 第一个参数为 true 则直接返回 true。所以它们的问题可能不会全部问到。
一个 S-表达式要么是一个原子，要么是一个 S-表达式列表（也可以是空列表）。
注意区分 eq?、=、eqan? 和 equal?。

Scheme 十诫之第一诫（终极式）

当对一个原子列表 lat 进行递归调用时，询问两个有关 lat 的问题：(null? lat) 和 else。
当对一个数字 n 进行递归调用时，询问两个有关 n 的问题：(zero? n) 和 else。
当对一个 S-表达式列表 l 进行递归调用时，询问三个有关 l 的问题：null? l、(atom? (car l)) 和 else。

Scheme 十诫之第四诫（终极式）

在递归时总是改变至少一个参数：

当对一个原子列表 lat 进行递归调用时，使用 (car lat)。
当对数字 n 进行递归调用时，使用 (sub1 n)。
当对一个 S-表达式进行递归调用时，只要 (null? lat) 和 (atom? (car l)) 都不为 true，那么就同时使用 (car lat) 和 (cdr lat)。

在递归时改变的参数，必须向着不断接近结束条件而改变。改变的参数必须在结束条件中得以测试：

当使用 cdr 时，用 null? 测试是否结束。
当使用 sub1 时，用 zero? 测试是否结束。

Scheme 十诫之第六诫

简化工作只在功能正确之后开展。

自定义函数

(rember* a l)

定义：移除列表 l 中的全部原子 a，以此类推。

实现：

(define rember*
  (lambda (a l)
    (cond
      ((null? l) (quote ()))
      ((atom? a)
        (cond
          ((eq? (car l) a) (rember* a (cdr l)))
          (else (cons (car l)
                      (rember* a (cdr l))))))
      (else (cons (rember* a (car l))
                  (rember* a (cdr l)))))))

(insertR* new old l)

定义：在列表 l 中的所有原子 old 后面插入原子 new。

实现：

(define insertR*
  (lambda (new old l)
    (cond
      ((null? l) (quote ()))
      ((atom? (car l))
        (cond
          ((eq? (car l) old)
            (cons old
                  (cons new
                        (insertR* new old (cdr l)))))
          (else (cons (car l)
                      (insertR* new old (cdr l))))))
      (else (cons (insertR* new old (car l))
                  (insertR* new old (cdr l)))))))

比较 rember* 和 insertR* 两个函数，看看是怎么问问题的。

(occur* a l)

定义：统计列表 l 中原子 a 出现的所有次数。

实现：

(define occur*
  (lambda (a l)
    (cond
      ((null? l) 0)
      ((atom? (car l))
        (cond
          ((eq? (car l) a)
            (add1 (occur* a (cdr l))))
          (else (occur* a (cdr l)))))
      (else (plus (occur* a (car l))
                  (occur* a (cdr l)))))))

(subst* new old l)

定义：把列表 l 中的所有原子 old 都替换为原子 new。

实现：

(define subst*
  (lambda (new old l)
    (cond
      ((null? l) (quote ()))
      ((atom? (car l))
        (cond
          ((eq? (car l) old)
            (cons new
                  (subst* new old (cdr l))))
          (else (cons old
                      (subst* new old (cdr l)))))
      (else (cons (subst* new old (car l))
                  (subst* new old (cdr l))))))))

(insertL* new old l)

定义：在列表 l 中的所有原子 old 前面插入原子 new。

实现：

(define insertL*
  (lambda (new old l)
    (cond
      ((null? l) (quote ()))
      ((atom? (car l))
        (cond
          ((eq? (car l) old)
            (cons new
                  (cons old
                        (insertL* new old (cdr l)))))
          (else (cons old
                      (insertL* new old (cdr l)))))
      (else (cons (insertL* new old (car l))
                  (insertL* new old (cdr l))))))))

(member* a l)

定义：判断原子 a 是否出现在列表 l 中。

实现：

(define member*
  (lambda (a l)
    (cond
      ((null? l) #f)
      ((atom? (car l))
        (or (eq? (car l) a)
            (member* a (cdr l))))
      (else (or (member* a (car l))
                (member* a (cdr l)))))))

回忆一下 or 的用法。

(leftmost l)

定义：找出非空 S-表达式列表 l 中最左边的原子。同时该列表不包含空列表元素。

实现：

(define leftmost
  (lambda (l)
    (cond
      ((atom? (car l)) (car l))
      (else (leftmost a (cdr l))))))

(eqlist? l1 l2)

定义：判断两个列表是否相等。

思考：需要问 9 个问题，因为处理列表有 3 种情况，两个列表就是 9 种情况。

实现：

(define eqlist?
  (lambda (l1 l2)
    (cond
      ((and (null? l1) (null? l2)) #t)
      ((and (null? l1) (atom? (car l))) #f)
      ((null? l1) #f)
      ((and (atom? (car l1)) (null? l2)) #f)
      ((and (atom? (car l1)) (atom? (car l2)))
        (and (eqan? (car l1) (car l2))
             (eqlist? (cdr l1) (cdr l2))))
      ((atom? (car l1)) #f)
      ((null? l2) #f)
      ((atom? (car l2)) #f)
      (else (and (eqlist? (car l1) (car l2))
                 (eqlist? (cdr l1) (cdr l2)))))))

(and (null? l1) (null? l2)) 和 (or (null? l1) (null?l2)) 可以确定 3 种情况，以此简化一下：

(define eqlist?
  (lambda (l1 l2)
    (cond
      ((and (null? l1) (null? l2)) #t)
      ((or (null? l1) (null? l2)) #f)
      ((and (atom? (car l1)) (atom? (car l2)))
        (and (eqan? (car l1) (car l2))
             (eqlist? (cdr l1) (cdr l2))))
      ((or (atom? (car l1)) (atom? (car l2))) #f)
      (else (and (eqlist? (car l1) (car l2))
                 (eqlist? (cdr l1) (cdr l2)))))))

(equal? s1 s2)

定义：判断两个 S-表达式是否相同。

实现：

(define equal?
  (lambda (s1 s2)
    (cond
      ((and (atom? s1) (atom? s2))
        (eqan? s1 s2))
      ((atom? s1) #f)
      ((atom? s2) #f)
      (else (eqlist? s1 s2)))))

同上，第二第三个问题可以归纳为 (or (atom? s1) (atom? s2))，简化版：

(define equal?
  (lambda (s1 s2)
    (cond
      ((and (atom? s1) (atom? s2))
        (eqan? s1 s2))
      ((or (atom? s1) (atom? s2))
        #f)
      (else (eqlist? s1 s2)))))

接下来用 equal? 重写 eqlist?：

(define eqlist?
  (lambda (l1 l2)
    (cond
      ((and (null? l1) (null? l2)) #t)
      ((or (null? l1) (null? l2)) #f)
      (else (and (equal? (car l1) (car l2))
                 (eqlist? (cdr l1) (cdr l2)))))))

(rember s l)

定义：详见第三篇，这里是用任意 S-表达式列表 l 替代 lat，任意 S-表达式 s 替代原子 a 之后的版本。用到了上述的 equal?。

实现：

(define rember
  (lambda (s l)
    (cond
      ((null? l) (quote ()))
      ((equal? (car l) s) (cdr l))
      (else (cons (car l)
                  (rember s (cdr l)))))))

如何向开源项目贡献代码

Sat, 08 Dec 2018 18:38:22 GMT

在写「The Little Schemer」知识点整理系列的时候，理想状态是我一口气把书看完，并快速概括出其中的要点并写下来。往往事与愿违。本文就是阅读此书过程中，“一口气”被分割成好几口气之后的附属品，根据这几天在 GitHub 上提交的几个有关代码高亮的 PR，谈谈前因后果以及心得体会。

1. 博客的代码高亮问题

1.1 起因

我在写到系列第三篇时，文章里的代码块比较多，却基本没有高亮。本着就算不是对读者，对自己来说观感也不佳的想法，开始着手解决这个问题。

1.2 经过

首先分析具体现象，发现不支持 scheme 的语法高亮，以前文章里所用到的 js bash 等语言就没有问题。

于是我们从源头——此博客的生成框架—— Hexo 开始一步步查找原因：

阅读其源码可以知道，它使用了业界运用最广泛的 highlight.js 来高亮代码；
再看 highlight.js 文档，发现它是支持像 Scheme 这样的 Lisp 语言的高亮的；
而后查看生成文章的页面元素，按照 Hexo 和 highlight.js 的设置，格式正确无误。

排除了框架自身的原因后，我们来看看主题部分。博客现在使用 NexT 主题，按照如下步骤寻找问题：

找到主题里设置高亮部分的 css，与 highlight.js 对 Scheme 语言的设置进行对比；
我们发现，在 highlightjs/highlight.js@8616294 这个 commit 里，引入了对 Lisp 语言更好的支持，其中新的 builtin-name 是 NexT 所欠缺的。

1.3 结果

解决方案：theme-next/hexo-theme-next#492

经过测试，证明上面得出的结论无误，只要在主题里的高亮部分也引入 builtin-name 这个新的 css class 就可以实现对 Scheme 的高亮。回去看之前的几篇文章，可以看到代码块的关键字部分已经被高亮为橘色。

2. Markdown 文件的代码高亮问题

2.1 起因

我是在 Typora 下完成的前三章整理，写作体验相当不错。但是当我从第四章开始使用 VS Code 书写 Markdown 之后，又出现了新的问题：Scheme 代码块不能被高亮，只有预览才可以。

2.2 经过

有了刚才的经验，我们先与现有的比较，发现常用语言表现良好。

继续。源头指向 VS Code，查看源码我们找到它用来描述 markdown 的文件： /extensions/markdown-basics/syntaxes/markdown.tmLanguage.json。可以看到里面有大量 fenced_code_block_language 字段，不言而喻，这些就是用来描述 markdown 里不同语言的代码块的。啊，果然没有 Scheme 语言的实现。

如果再仔细读每个 fenced_code_block_language 字段下的内容，会发现大同小异，有所变化的只有匹配正则以及每个语言所对应的 "patterns": "source.language"。

那么 source.language 是哪里来的呢。是通过叫 language identifier 的东西定义出来的。观察 /extensions 目录，包含了一大堆常用语言的目录，这些就是 VS Code 内建的语言支持，一种语言即一个内建插件，也相应地定义了该语言的 language identifier。没有列出的语言需要通过插件引入，于是我们可能需要自行创建对 Scheme 语言的定义了。在此之前，最好搜索一下 VS Code 市场，也许会发现目标语言已经有了一份相对完整的定义，比如我找到了 vscode-scheme。试用一下，咦，.scm .rkt 等文件的高亮和快捷键什么的倒是有了，markdown 里面代码块的高亮却是不支持。事情到现在应该比较清晰了，我们的目标就是去扩展这个插件。

下一个问题，如何扩展？天下代码一大抄 😂，我们搜索 VS Code 的 Issues 或者 Pull requests，看是否有过类似的实现。最后找到一个可以直接注入配置的例子：injection-example。蛋疼的搜索和 debug 过程略去不表，最终实现看上去挺简单的：

根据例子新建一个该语言 markdown 部分的描述文件 scheme.markdown.tmLanguage.json；
在 package.json 里面引入此文件并定义对应的 scopeName，注入 markdown 配置；
这时 VS Code 的 Markdown 插件可以读到这份配置，当在代码块里看到 scheme 时，就调用 vscode-scheme 已经定义好的 parser。

2.3 结果

解决方案：sjhuangx/vscode-scheme#3

3. 面向需求编程

以前总在想着怎么造轮子，不出意外，想造的轮子都已经有了相应的实现。虽然自己可以继续造一个，但是没有必要。所谓“开源”的目的是什么呢？其中一点就是可以通过社区改进项目中的不足。既然当不成 Maintainer，那就做个 Contributor 吧，解决自己需求的同时，完善和加强原项目的功能。这就是我认为向开源项目贡献代码最直接而简单的方式。

有一个特别佩服的人—— @Easy，观察他的日常微博不难发现，他通常都会因为某个在市面上暂时没有的功能，而根据自己的需求马上动手实现一份，而且产出速度特别惊人。我很想学习其中的精神，缺什么写什么。

需求不是经常会有，但是一旦来临，我希望自己有这个能力去完成它。以上就是自己对于这几天提交的 PR 的一个记录。短期目标：Make my life better。至少是开发生活吧。🎉

The Little Schemer 知识点整理（四）：数字游戏

Thu, 06 Dec 2018 14:26:56 GMT

准备知识

所有数字都是原子；
暂时只考虑非负整数，0、1、2、3……；
用 (zero? n) 判断数字 n 是否为零；
tup 是元组 Tuple 的缩写，用来表示一个数字列表，() 也是一个 tup；
(and a b) : 类似于 (or a b)，&& 和 || 的区别(?)；
= 用来测试数字类型的原子，eq? 用来测试其他类型的原子；
number? 是一个基本函数，判断参数是否为数值型原子；
空心加号（区别于数学符号+）打不出来，所以原书中的空心加号用 plus 代替；

重要

以下定义可以说明我们的操作并不违反 Scheme 十诫。详见起飞式。

zero? 之于数字相当于 null? 之于列表；
add1 之于数字，相当于 cons 之于列表。

Scheme 十诫之第一诫（起飞式）

当对一个原子列表 lat 进行递归调用时，询问两个有关 lat 的问题：(null? lat) 和 else。
当对一个数字 n 进行递归调用时，询问两个有关 n 的问题：(zero? n) 和 else。

Scheme 十诫之第四诫（起飞式）

在递归时总是改变至少一个参数。该参数必须向着不断接近结束条件而改变。改变的参数必须在结束条件中得以测试：当使用 cdr 时，用 null? 测试是否结束；当使用 sub1 时，用 zero? 测试是否结束。

Scheme 十诫之第五诫

当用 plus 构建一个值时，总是使用 0 作为结束代码行的值，因为加上 0 不会改变加法的值。
当用 × 构建一个值时，总是使用 1 作为结束代码行的值，因为乘以 1 不会改变乘法的值。
当用 cons 构建一个值时，总是考虑把 () 作为结束代码行的值。

自定义函数

(add1 n)

定义：n 加一。

实现：

(define add1
  (lambda (n)
    (+ n 1)))

(sub1 n)

定义：n 减一。

实现：

(define sub1
  (lambda (n)
    (- n 1)))

(plus n m)

打不出空心加号，用 plus 代替

定义：把 n 与 m 相加。用到了上面定义的 add1 和 sub1，以下函数的用法相似。

实现：

(define plus
  (lambda (n m)
    (cond
      ((zero? m) n)
      (else (add1 (plus n (sub1 m)))))))

(minus n m)

打不出空心减号，用 minus 代替

定义：把 n 与 m 相减。

实现：

(define minus
  (lambda (n m)
    (cond
      ((zero? m) n)
      (else (sub1 (minus n (sub1 m)))))))

(addtup tup)

定义：通过统计参数 tup 中所有数字之和来构建一个新的数字。

实现：

(define addtup
  (lambda (tup)
    (cond
      ((null? tup) 0)
      (else (plus (car tup) (addup (cdr tup)))))))

(× n m)

定义：把 n 与 m 相乘。

实现：

(define ×
  (lambda (n m)
    (cond
      ((zero? m) 0)
      (else (plus n (× n (sub1 m)))))))

(tup+ tup1 tup2)

定义：对于相同长度的 tup1 和 tup2，其将 tup1 的第一个数字加到 tup2 的第一个数字上，然后将tup1 的第二个数字加到 tup2 的第二个数字上，以此类推，构建出结果一个新的 tup。

实现：

(define tup+
  (lambda (tup1 tup2)
    (cond
      ((and (null? tup1) (null? tup2)) (quote ()))
      (else (cons (plus (car tup1) (car tup2))
                  (tup+ (cdr tup1) (cdr tup2)))))))

还可以改造成对任意两个 tup 的 tup+：

(define tup+
  (lambda (tup1 tup2)
    (cond
      ((null? tup1) tup2)
      ((null? tup2) tup1)
      (else (cons (plus (car tup1) (car tup2))
                  (tup+ (cdr tup1) (cdr tup2)))))))

(> n m)

定义：比较 n 与 m 的大小，如果前者大于后者，则返回 #t，否则返回 #f。

实现：

(define >
  (lambda (n m)
    (cond
      ((zero? n) #f)
      ((zero? m) #t)
      (else (> (sub1 n) (sub1 m))))))

注意两个条件的顺序，下同。

(< n m)

定义：比较 n 与 m 的大小，如果前者小于后者，则返回 #t，否则返回 #f。

实现：

(define <
  (lambda (n m)
    (cond
      ((zero? m) #f)
      ((zero? n) #t)
      (else (< (sub1 n) (sub1 m))))))

(= n m)

定义：比较 n 与 m 的大小，如果两者相等，则返回 #t，否则返回 #f。

实现：

(define =
  (lambda (n m)
    (cond
      ((zero? m) (zero? n))
      ((zero? n) #t)
      (else (= (sub1 n) (sub1 m))))))

或者：

(define =
  (lambda (n m)
    (cond
      ((> n m) #f)
      ((< n m) #f)
      (else #t))))

(↑ n m)

定义：计算 n 的 m 次方。

实现：

(define ↑
  (lambda (n m)
    (cond
      ((zero? m) 1)
      (else (× n (↑ n (sub1 m)))))))

(÷ n m)

定义：把 n 与 m 相除，只求商。

实现：

(define ÷
  (lambda (n m)
    (cond
      ((< n m) 0)
      (else (add1 (÷ (minus n m) m))))))

(length lat)

定义：求列表 lat 包含的元素个数。

实现：

(define length
  (lambda (lat)
    (cond
      ((null? lat) 0)
      (else (add1 (length (cdr lat)))))))

(pick n lat)

定义：获取列表 lat 中的第 n 个元素。

实现：

(define pick
  (lambda (n lat)
    (cond
      ((zero? (sub1 n)) (car lat))
      (else (pick (sub1 n) (cdr lat))))))

(rempick n lat)

定义：剔除列表 lat 中的第 n 个元素，以此构建一个新列表。

实现：

(define rempick
  (lambda (n lat)
    (cond
      ((zero? (sub1 n)) (cdr lat))
      (else (cons (car lat)
                  (rempick (sub1 n) (cdr lat)))))))

或者（使用下述函数 one?）：

(define rempick
  (lambda (n lat)
    (cond
      ((one? n) (cdr lat))
      (else (cons (car lat)
                  (rempick (sub1 n) (cdr lat)))))))

(no-nums lat)

定义：返回一个列表，该列表移除了原始 lat 中的所有数字原子。

实现：

(define no-nums
  (lambda (lat)
    (cond
      ((null? lat) (quote ())
      ((number? (car lat)) (no-nums (cdr lat)))
      (else (cons (car lat)
                  (no-nums (cdr lat))))))))

(all-nums lat)

定义：返回一个列表，该列表找出原始 lat 中的所有数字原子，并组成一个新的 tup。

实现：

(define all-nums
  (lambda (lat)
    (cond
      ((null? lat) (quote ())
      ((number? (car lat))
        (cons (car lat)
              (all-nums (cdr lat))))
      (else (all-nums (cdr lat)))))))

(eqan? a1 a2)

定义：如果参数 a1 和 a2 是同一个原子则返回 true（#t）。

实现：

(define eqan?
  (lambda (a1 a2)
    (cond
      ((and (number? a1) (number? a2))
        (= a1 a2))
      ((or (number? a1) (number? a2))
        (#f))
      (else (eq? a1 a2)))))

(occur a lat)

定义：统计原子 a 在列表 lat 中出现的次数。

实现：

(define occur
  (lambda (a lat)
    (cond
      ((null? lat) 0)
      ((eq? (car lat) a) (add1 (occur a (cdr lat))))
      (else (occur a (cdr lat))))))

(one? n)

定义：如果 n 为 1，则返回 #t，否则返回 #f。

实现：

(define one?
  (lambda (n)
    (cond
      ((zero? (sub1 n)) #t)
      (else #f))))

★ 或者简化并移除 (cond ...)：

(define one?
  (lambda (n)
    (= n 1)))

The Little Schemer 知识点整理（三）：用 cons 构筑恢宏

Wed, 05 Dec 2018 13:39:58 GMT

Scheme 十诫之第二诫

使用 cons 来构建列表。

Scheme 十诫之第三诫

构建一个列表的时候，描述第一个典型的元素，之后 cons 该元素到一般性递归上。

Scheme 十诫之第四诫

在递归时总是改变至少一个参数。该参数必须向着不断接近结束条件而改变。改变的参数必须在结束条件中得以测试：当使用 cdr 时，用 null? 测试是否结束。

自定义函数

(rember a lat)

定义：rember 函数将一个原子 a 和一个列表 lat 作为参数，生成一个新列表，新列表为剔除了首个 a 的 lat。

实现：

(define rember
  (lambda (a lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) a) (cdr lat))
      (else (cons (car lat)
                  (rember a (cdr lat)))))))

(firsts l)

定义：firsts 函数以一个列表 l 为参数，该列表要么为空列表，要么只包含非空列表。该函数构建出一个新列表，新列表中的元素由列表 l 中每个内部列表的第一个 S-表达式组成。

实现：

(define firsts
  (lambda (l)
    (cond
      ((null? l) (quote ()))
      (else (cons (car (car l))
                  (firsts (cdr l)))))))

(insertR new old lat)

定义：insertR 函数有三个参数：原子 new 与 old，以及一个列表 lat。该函数在 lat 的第一个 old 后面插入 new，并返回新的列表。

实现：

(define insertR
  (lambda (new old lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) old)
        (cons old
              (cons new (cdr lat))))
      (else (cons (car lat)
                  (insertR new old (cdr lat)))))))

(insertL new old lat)

定义：同上，不过是在列表 lat 中的第一个 old 前面插入 new。

实现：

(define insertL
  (lambda (new old lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) old) (cons new lat))
      (else (cons (car lat)
                  (insertL new old (cdr lat)))))))

(subst new old lat)

定义：用 new 替换列表 lat 中的第一个 old。

实现：

(define subst
  (lambda (new old lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) old) (cons new (cdr lat)))
      (else (cons (car lat)
                  (subst new old (cdr lat)))))))

(subst2 new o1 o2 lat)

定义：用 new 替换列表 lat 中的第一个 o1 或者第一个 o2。

实现：

(define subst2
  (lambda (new o1 o2 lat)
    (cond
      ((null? lat) (quote ()))
      ((or (eq? (car lat) o1) (eq? (car lat) o2))
        (cons new (cdr lat)))
      (else (cons (car lat)
                  (subst2 new o1 o2 (cdr lat)))))))

(multirember a lat)

定义：类似于 rember，不过是把 lat 中的所有 a 都移除。

实现：

(define multirember
  (lambda (a lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) a) (multirember a (cdr lat)))
      (else (cons (car lat)
                  (multirember a (cdr lat)))))))

(multiinsertR new old lat)

定义：类似于 insertR，不过是在 lat 中的所有 old 后面都插入 new。

实现：

(define multiinsertR
  (lambda (new old lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) old)
        (cons old
              (cons new
                    (multiinsertR new old (cdr lat)))))
      (else (cons (car lat)
                  (multiinsertR new old (cdr lat)))))))

(multiinsertL new old lat)

定义：类似于 insertL，不过是在 lat 中的所有 old 前面插入 new。

实现：

(define multiinsertL
  (lambda (new old lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) old)
        (cons new
              (cons old
                    (multiinsertL new old (cdr lat)))))
      (else (cons (car lat)
                  (multiinsertL new old (cdr lat)))))))

(multisubst new old lat)

定义：类似于 subst，不过是用 new 替换列表 lat 中的所有 old。

实现：

(define multisubst
  (lambda (new old lat)
    (cond
      ((null? lat) (quote ()))
      ((eq? (car lat) old)
        (cons new
              (multisubst new old (cdr lat))))
      (else (cons (car lat)
                  (multisubst new old (cdr lat)))))))

The Little Schemer 知识点整理（二）：处理，处理，反复处理……

Wed, 05 Dec 2018 13:38:45 GMT

准备知识

(atom? a) : 判断 S-表达式 a 是否为一个原子。
(else ...) : 总是 true。
(or a b) : 询问两个问题 a 和 b，一次问一个。如果 a 的答案为 true，则停止问第二个问题 b，答案为 true。否则继续询问，答案为 b 的答案（true 或者 false）。

(cond ...) : 问问题。
(lambda ...) : 创建一个函数。
(define ...) : 为函数命名。

Scheme 十诫之第一诫

在表述任意函数时，总是将询问 null? 作为诸问题之首。

自定义函数

(lat? l)

定义：lat? 函数判断列表 l 中的元素是否都是原子。

实现：

(define lat?
  (lambda (l)
    (cond
      ((null? l) #t)
      ((atom? (car l)) (lat? (cdr l)))
      (else #f))))

(member? a lat)

定义：member? 判断列表 lat 中是否存在 a。

实现：

(define member?
  (lambda (a lat)
    (cond
      ((null? lat) #f)
      (else (or (eq? (car lat) a)
                (member? a (cdr lat)))))))

The Little Schemer 知识点整理（一）：玩具总动员

Wed, 05 Dec 2018 12:42:06 GMT

此系列按照章节整理了「The Little Schemer：递归与函数式的奥妙」的全书知识点。

备忘录，仅供参考。

Scheme 五法

car 之法则

基本元件 car 仅定义为针对非空列表。
cdr 之法则

基本元件 cdr 仅定义为针对非空列表。任意非空列表的 cdr 总是另一个列表。
cons 之法则

基本元件 cons 需要两个参数。第二个参数必须是一个列表。结果是一个列表。
null? 之法则

基本元件 null? 仅定义为针对列表。
eq? 之法则

基本元件 eq? 需要两个参数。每个参数都必须是一个非数字的原子。

基本元件使用方法

(car l) : 获取列表 l 的第一个 S-表达式。
(cdr l) : 获取列表 l 去除 (car l) 的部分。
(cons a l) : 将 S-表达式 a 添加到列表 l 的开头处。
(null? l) : 判断列表 l 是否为空列表。
(eq? a b) : 判断 a 和 b 是否相等。

Arch Linux 的简化版安装步骤整理

Thu, 25 Oct 2018 14:46:04 GMT

昨天下午摸鱼的时候心血来潮，在 Virtual Box 中安装了一遍 Arch Linux。很久以前虽然也装过，还是带 X 的，但是这回装个不带 X 的居然还碰到了一堆坑。于是整理出一份精简版的安装步骤，供后来者（包括健忘的自己）参考，少走弯路。

一、安装准备

将 Arch Linux 镜像作为介质导入新建的 Virtual Box 虚拟机，启动进入镜像系统，此步详情略去不表。

确保联网

ping google.com

连不上的话暂时就不用往下看了。

更新系统时间

timedatectl set-ntp true

建立硬盘分区

fdisk /dev/sda

进入 fdisk 之后：

n
p
默认全部按回车
w

以上步骤是把 /dev/sda 分为只带一个 /dev/sda1 分区的磁盘。

格式化分区

mkfs.ext4 /dev/sda1

挂载分区

将根分区挂载到 /mnt：

mount /dev/sda1 /mnt

二、安装

选择镜像

编辑 /etc/pacman.d/mirrorlist，大陆用户最好找标识为 China 的镜像地址，选一个把它放到第一行。比如：

# 中国科学技术大学开源软件镜像
Server = http://mirrors.ustc.edu.cn/archlinux/$repo/os/$arch

安装基本系统

安装 base 和 base-devel 组中的内容到 /mnt：

pacstrap -i /mnt base base-devel

三、配置系统

fstab

genfstab -U /mnt >> /mnt/etc/fstab

chroot

“change root”，切换到新安装的系统：

arch-chroot /mnt

设置时区

ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
hwclock --systohc

本地化

编辑 /etc/locale.gen，找到下面几行取消注释（zh_CN 可以不用）：

en_US.UTF-8 UTF-8
zh_CN.UTF-8 UTF-8

保存退出后执行下方命令生成 locale 信息：

locale-gen

创建 /etc/locale.conf，添加默认 LANG 信息：

LANG=en_US.UTF-8

主机名

创建 /etc/hostname，选定一个主机名比如 myhostname：

myhostname

编辑 /etc/hosts，添加对应信息：

127.0.0.1	 localhost
::1		     localhost
127.0.1.1	 myhostname.localdomain	myhostname

网络配置

systemctl start dhcpcd
systemctl enable dhcpcd

Root 密码

passwd

安装引导程序

pacman -S grub
grub-install --target=i386-pc /dev/sda
grub-mkconfig -o /boot/grub/grub.cfg

四、重启

exit
umount -R /mnt
shutdown -h now

从介质中移除镜像，重启虚拟机，进入引导界面，默认选择第一个选项。

至此我们的安装工作已经全部完成，并已登录为 root 用户。

五、收尾

创建用户

新建一个名为 newuser 的用户，并以 zsh 作为默认 shell：

useradd -m -g users -G wheel -s /bin/zsh newuser

设置密码：

passwd newuser

编辑 /etc/sudoers，取消注释下面这行：

%wheel ALL=(ALL) ALL

之后进入系统就可以使用 newuser 登录啦，并配合 sudo 提权。

滚动更新

Arch Linux 怎么能少了更新呢，马上滚一发 🎉 ：

pacman -Syu

其实已经是最新了（。

六、注意事项

新系统默认没有 vim，所以 chroot 之后需要先安装它，或者暂时使用 nano；
官方文档最靠谱；

七、参考链接

如何为微信开发建立本地反向代理

Thu, 11 Oct 2018 13:08:33 GMT

假定你已经在微信公众号配置好相应的域名，比如 www.example.com。

修改 `hosts`

macOS 下：sudo vim /etc/hosts，添加一条记录：

127.0.0.1 www.example.com

修改 `nginx` 配置

添加一个配置文件：

server {
    listen 80;
    server_name www.example.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
    }
}

其他的 location 或其他参数可以按照规则自行添加。完成之后重新加载：

nginx -s reload

删除微信开发者工具 HSTS 缓存

如果后台服务开启了 HSTS，并且在工具里面打开过上述域名的话，之后都会强制跳转到 https 站点，导致我们无法直接访问 http 站点，这时我们删除：

rm -rf $HOME/Library/Application\ Support/微信web开发者工具

然后重启开发者工具即可。

在开发者工具里访问 http://www.example.com，它就是跑在本地 8080 端口上的应用。于是接下来就可以进行无痕微信开发啦。

按应用名字杀进程的 fish shell 脚本

Wed, 08 Aug 2018 17:20:13 GMT

如题，只是一个包装成函数的 fish 脚本。因为有些应用偶尔会进入无响应状态，不想每次都手动查找端口来杀进程。

function killit
    kill -9 (string split ' ' (ps -e | grep -i $argv))[1]
end

用法

以上 3 行放到 ~/.config/fish/config.fish 里面。请谨慎使用!!!

# kill f*king Chrome
killit Chrome
# case insensitive
killit cHroME

不会覆盖所有需求，主要是自己用得爽 🤣

2018.09.04

发现 pkill 命令能更加简单地完成需求：

# -9: kill
# -i: case insensitive
# -o: oldest process
pkill -9 -io Chrome

Hexo 设置备份

Tue, 07 Aug 2018 16:51:07 GMT

I’m back. 备份一下现在的 Hexo 设置。

主题和插件

# 主题
git clone https://github.com/theme-next/hexo-theme-next themes/next
# RSS
npm i hexo-generator-feed
# 部署
npm i hexo-deployer-sftp
# 优化
npm i hexo-html-minifier hexo-clean-css hexo-uglify

_config.yml - 根目录

# Docs: https://hexo.io/docs/configuration.html

# Site
title: 星雨之夜
author: Twinkle
language: zh-CN

# URL
permalink: :title/

# disable pagination for archive page
archive: 1

# Extensions
theme: next

# Deployment: https://hexo.io/docs/deployment.html#SFTP
deploy:
  type: sftp
  host: <host>
  user: <user>
  remotePath: [remote path]
  port: [port]
  privateKey: [path/to/privateKey]
  passphrase: [passphrase]

_config.yml - 主题目录

v6.6.0

favicon:
  small: /favicon-16x16.png
  medium: /favicon-32x32.png
  apple_touch_icon: /apple-touch-icon.png
  safari_pinned_tab: /safari-pinned-tab.svg
  android_manifest: /site.webmanifest
  ms_browserconfig: /browserconfig.xml

footer:
  since: 2015
  icon:
    name: heart
    color: '#ff0000'
  powered:
    version: false

creative_commons:
  post: true

seo: true

menu:
  tags: /tags/ || tags
  categories: /categories/ || th
  about: /about/ || user

scheme: Pisces

social:
  GitHub: https://github.com/saintwinkle || github
  Weibo: https://weibo.com/levicorpus || weibo
  Twitter: https://twitter.com/saintwinkle || twitter

social_icons:
  icons_only: true
  transition: true

avatar:
  url: /uploads/avatar.webp
  rounded: true
  opacity: 0.85

sidebar:
  b2t: true
  scrollpercent: true

post_meta:
  updated_at:
    enabled: false

disqus:
  enable: true
  shortname: saintwinkle
  count: false
  lazyload: true

mobile_layout_economy: true

android_chrome_color: '#222'

google_analytics: UA-121613404-1

leancloud_visitors:
  enable: true
  app_id: <app_id>
  app_key: <app_key>
  security: false

motion:
  async: true

vendors:
  jquery: //cdn.jsdelivr.net/npm/jquery@2.1.3/dist/jquery.min.js
  velocity: //cdn.jsdelivr.net/npm/velocity-animate@1.2.1/velocity.min.js
  velocity_ui: //cdn.jsdelivr.net/npm/velocity-animate@1.2.1/velocity.ui.min.js
  fontawesome: //cdn.jsdelivr.net/npm/font-awesome@4.7.0/css/font-awesome.min.css

Hitokoto.us（一言）的 API 爬虫

Tue, 05 May 2015 00:00:00 GMT

爬虫一向都很有意思，当你把想要的内容从网络中抓取并保存下来的时候，一定会得到“占有”它的满满的幸福感 (๑´ڡ`๑)

大部分爬虫是很繁琐的，需要手动写出许多规则来过滤大部分的无效内容；有些就很简单了，可以通过网站提供的 API 来获取信息，这也是为开发者们提供的便利。本文主要记录爬取一言 - ヒトコト站点 API 的过程。

爬虫目标

爬取通过 API 能够得到的所有内容，基于 Node.js 。

内容存取

使用 MongoDB 存储数据，mongoose 操作数据。

代码主体

首先访问一次 API 地址：http://api.hitokoto.us/rand，看看它到底提供了哪些数据（手动格式化了一下）：

{
  "hitokoto": "我从小就害怕虫子",
  "cat": "g",
  "author": "firo",
  "source": "小小闲",
  "like": 9,
  "date": "2012.07.22 12:02:01",
  "catname": "其他",
  "id": 1342929721000
}

随后就能组织写入数据库的数据结构了，与上述 json 数据格式保持一致，保存并命名为 hitokoto.js：

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

// 新建 Schema
var hitokotoSchema = new Schema({
  hitokoto: String,
  cat: String,
  author: String,
  source: String,
  like: Number,
  date: String,
  catname: String,
  _id: Number,
});

// 导出 model
module.exports = mongoose.model('Hitokoto', hitokotoSchema);

然后新建 index.js 文件，导入上面的数据模型，获取 API 信息并根据已经组织好的数据结构写入数据库：

var Hitokoto = require('./hitokoto');
var mongoose = require('mongoose');
var http = require('http');

// 连接数据库，首先确保已在本地运行 mongod
mongoose.connect('mongodb://localhost/hitokoto');
mongoose.connection.on('error', function() {
  console.log('mongodb connection error');
});

// 循环发送 GET 请求
// 不用 setTimeout，任性，可能造成的问题暂时不管了 XD
setInterval(function() {
  http
    .get('http://api.hitokoto.us/rand', function(res) {
      res.on('data', function(chunk) {
        // 以 JSON 格式取得数据
        data = JSON.parse(chunk);
        // 查询获取到的数据是否已经写入数据库
        Hitokoto.find({ _id: data.id }, function(err, current) {
          if (err) return console.log(err);

          // 是则立即返回，进行下一次读取
          if (current.length != 0) return;
          // 否则将新数据写入数据库
          var hitokoto = new Hitokoto({
            hitokoto: data.hitokoto,
            cat: data.cat,
            author: data.author,
            source: data.source,
            like: data.like,
            date: data.date,
            catname: data.catname,
            _id: data.id,
          });

          hitokoto.save(function(err) {
            if (err) return console.log(err);
            console.log(data.id + ' saved!');
          });
        });
      });
    })
    .on('error', function(err) {
      console.log(err);
    });
}, 1500); // 读取时间间隔1.5秒

最后应该就可以正常运行了，保存成功的 id 值会在终端进行输出：

npm install mongoose
node index.js

截止到目前为止，共获取到 483 条一言的数据，可能还有几条，也可能没有了，不知道有没有办法知道是否全部爬完，或者有更高效的方法进行爬取？

其实本想把一言这么好玩的东西放进博客的，无奈审美太渣，感觉放哪儿都不好看，还是不破坏主题了，就这样吧 233

整理 SublimeLinter 的安装步骤

Mon, 04 May 2015 00:00:00 GMT

前阵子终于搞定 SublimeLinter 让它正常工作了，却一直没时间去记录折腾的经历（没错，其实是懒）。这么一拖，微软居然就发布了 Visual Studio Code，看到大多数评价都是“赞赞赞”、“快快快”、“巨硬大法好”，让吾等 Sublime 党的内心产生了动摇。在彻底叛变之前我还是决定来写完这篇心得体会（以作纪念）。

因为项目上用 Coffeescript 来写 JS，所以这里以 coffeelint 为例。APM 流派的用户慎用，安装之后会有轻微的卡顿感。

安装 coffeelint

参照 Linter Installation 的 前两个 步骤。

安装 SublimeLinter

参照 Installing via Package Control 的步骤。

关联 coffeelint 到 SublimeLinter

确定路径

参照 Finding a linter executable，使用 which coffeelint 命令。

关联路径

可以通过以下两种方式进行关联：

通过 SublimeLinter 的配置文件

打开 Preferences - Package Settings - SublimeLinter - Settings - User，在 paths 中添加刚刚找到的路径，比如我的路径是这样的：

"paths": {
  "linux": [
    "/home/twinkle/.nvm/v0.10.38/bin"
  ],
  "osx": [],
  "windows": []
}

通过 shell 启动脚本

我同时使用 nvm 和 zsh，所以按照 Linter Installation 的第三步，将 ~/.nvm/nvm.sh 写入 .zshenv 文件中，使 Node 和 coffeelint 的路径能够被正确载入。

其他情况请参照 Augmenting PATH 的步骤。

重启 Sublime Text 或者重新登录系统即可生效，记录完毕。

记录 Xfce 的一些配置

Sat, 25 Apr 2015 00:00:00 GMT

这次我为了透明效果叛变到了 Xfce，而且我很喜爱简洁风格，确实应该来尝试一下这款轻量级的桌面。当然，折腾一番流行度仅次于 KDE / GNOME 的桌面环境才符合折腾党的特点嘛。此文用于记录我的一些初始配置，只保证在 Archlinux 下的可行性，可能会有更新（惰性使它成为了小概率事件）。

透明

首先当然是调节一下透明效果，在 Settings - Window Manager Tweaks - Compositor 里面，怎么好玩怎么设置。当然，桌面 panel 组件的效果还能另外设置。

Dock

Xfce 自带的 Dock 不好用，这里的替代品是 Docky 或者 Plank，我选择了前者，感觉它的主题更好看。不过启动后需要把 Settings - Window Manager Tweaks - Compositor - Show shadows under dock windows 这项关闭，否则会有奇怪的边框阴影。

音量条

如果你的电脑带有亮度和音量调节快捷键的话，你会发现调节亮度的时候通知区域会显示相应的亮度条，但是音量却没有。这里需要安装 xfce4-volumed，重新登录后生效。另外，我把通知显示时长由默认的 10 秒改为了 5 秒。

主题（窗口、图标和鼠标指针）

除了在 openSUSE 下用默认的 oxygen 之外，其他我无一例外都使用了 Numix，可以从官方源获取到 numix-themes。 Numix 还配套了图标和鼠标指针，不过这里我只选了前者，可以通过 AUR 获取 numix-circle-icon-theme-git，圆形的扁平化设计感觉非常赞，看上去也很统一，治好了我多年的强迫症。至于指针，我的选择是最近发布的一款 breeze-default，不过奇怪的是 AUR 中有 breeze 的其他几款，却唯独没有 default，明明觉得它最好看 QAQ 这里是主页：Breeze Serie。

安装软件

因为电脑主要用于娱乐以及开发，所以安装了如下软件：

Google Chrome：90% 以上的时间开着上网，外加 F12 调试页面
Sublime Text 3：超强大的文本编辑器，装上各种插件之后带你飞（内存不够用不起 WebStorm）
gVim：装着玩的
Gimp：偶尔处理图片（只会裁剪、缩放和取色）
SMPlayer：配合 youtube-dl 和 mpv 能够观看很多网站的视频，再也不怕 Flash 把电脑变烤炉啦
Firefox：备胎，偶尔用于调试页面兼容性
Steam：买买买买买！我的 ID：saintwinkle，欢迎加好友 XD
Screenshot：咔嚓 ☆~

其实大多数问题 / 配置都能在 Xfce (简体中文) - ArchWiki 上找到，这里只是略微做了下个人归纳，如有雷同，都是我抄袭的。

下面放一张桌面截图：

Linux 各发行版的体验报告

Sun, 12 Apr 2015 00:00:00 GMT

大约在 10 个月之前，我正式开始使用 Linux 作为日常操作系统。到现在为止也积累了一些装机和使用经验，下面来谈一谈我所使用过的几种发行版及其桌面环境，只说体验和评价 XD

1. Ubuntu

最初我选择了 Ubuntu 作为入门系统，原因很简单，它作为世界上使用最为广泛、用户数量最多的 Linux 发行版，如果遇上问题，能够很容易找到解决方案，可以省去初学者不少麻烦。以下还得分别说一说先后用的两种桌面环境（Desktop Environment，DE）。

1.1 Unity

Unity 是 Ubuntu 的默认桌面环境，集成性能很不错，自带的软件也很多，安装完成就能满足基本的日常需求了。它还带有全局菜单，可能用过 Mac 的会比较熟悉，对我来说却不怎么用得上。然后从我的审美角度，感觉它的界面只能算是中规中矩。不过对于中文有很好的支持，各个界面的汉化非常完整，对于懒得看英文的同学，居家旅行必备呀。

1.2 GNOME

完全是因为觉得 Gnome 比 Unity 好看才换成这个的，没了。

好，说完 DE 我们来讲讲 Ubuntu 本身，对于大神们谈到的稳定性，我是几乎感受不出来的，反正更新没挂过，系统一直正常运行，期间还从 12.04 升级到了 14.04。使用过程中反正还是会碰到该碰到的问题，像命中注定一样，然后谷歌一下，解决。搜索大多数 Linux 相关的问题时，搜索结果里面必然会出现 Ubuntu 的字眼。还有个比较难搞定的双显卡问题，Ubuntu 也已经自带了独显的专有驱动，更换驱动之后能通过专有驱动配置来切换显卡，电脑就不怎么会烫得能煮鸡蛋了。

总之，推荐初学者使用发自真心！！！

2. Arch Linux

怀着又爱又恨的心情打下了这个小标题。重新安装整整 13 遍！才成功进入自己想要的 Gnome 桌面，别问我为什么把这个数字记得这么清楚。

Arch 是以激进的滚动升级著称的发行版，也是难以安装的发行版：

前者的特性给一些软件使用者带来了春风，它随时提供软件最新版本的更新以及内核的升级；不过同时也导致用户经常需要进行更新系统，否则升级时很容易带来兼容性问题以及没有发现的新 bug，也就是“滚挂”。
后者的这项特点就差点把我搞崩溃了。也不知道是信仰得到了充值还是什么，居然从全黑的命令行一步步成功安装出了一个能进桌面的系统，可能以后都不想再次体验这个过程了。不过我很喜欢验证事物的两面性，虽然过程很痛苦，但是学到了很多之前 GUI 安装所看不到的东西，理解了安装界面所引导我们做的每一步操作分别代表什么，可以说对 Linux 的了解都有了一小步的提升。

这里需要隆重介绍一位嘉宾 —— Yaourt，它为我们的 Arch 带来了无数的软件，一条 yaourt xxx 命令就能得到带 xxx 关键字的所有软件，包括了 Official（官方仓库）和 AUR（用户仓库）。真的比其他发行版的工具方便很多很多很多很多……

同时，Arch 的最小化安装比其他“笨重”的发行版（集成 Gnome 或者 KDE）基本都能少 1000 个左右的软件包，做到了真正的轻量，完全就是简洁主义者的福音。极高的定制度也带来了软件与运行环境的缺失，要做到流畅使用还是需要花费一番功夫的。

2.1 Antergos

Antergos 是基于 Arch 的一个发行版，它提供了 GUI 安装界面，想体验 Arch 而又觉得安装麻烦的同学可以试试这个，不出意外的话能够一遍安装成功。

综上，Arch Linux 适合喜欢折腾的同学来玩，不过就算是新手，我想也是完全可以入坑的，因为它的 Wiki 真的很强大，针对性极强，一般的问题都可以找得到（啃得动英文的话）。

3. openSUSE

啊啊啊啊啊好喜欢！这是 openSUSE 给我的第一感觉。玩了这么久的 Linux 居然还没用过 KDE 桌面未免也太失败了，而新装的 SUSE 马上弥补了这份失落感。

因为用的时间还不算太久，暂且还只能说，这是一个漂亮的系统，绝对会让你满意。虽然比之 Arch 的 AUR 还略有不足，但是 https://software.opensuse.org 的软件也很丰富，况且 SUSE 还拥有 OBS 这神一样的编译服务。待我了解得多一些再来深入。

我在刚装上 openSUSE 的时候发过一条 G+：装机 V4.0，它给我带来了 3W+ 的访问量，有点受宠若惊。

总结

除了上述的几种发行版之外，我还安装过 Linux Mint、Slackware，前者是因为当时正在使用 Ubuntu 的缘故觉得大同小异所以没有深入体验；后者是因为使用者实在是不多，担心出问题后没法解决，也难怪有个“阿卡林”的别称(ゝ ∀･) 我在服务器上面使用 CentOS，除了偶尔登录测试下代码也还没法去体会它的精髓。可能我真的错过了什么？谁知道呢。

新工作，新开始

Tue, 07 Apr 2015 00:00:00 GMT

换工作已经一个多月了，很惭愧在毕业后的一年半时间里从来没有好好总结过。还是不想被往事纠缠太多，于是就来写一写现在与未来的流水账吧。

过去 (´・ω・｀)

在回忆里面。

现在 ´ ▽ ` )ﾉ

我很庆幸能得到这份工作，它使我从一名软件攻城狮正式转型为前端小码农，这就是我现在所想要的、所喜欢的事情。

为什么选择前端？正经的回答是：因为好玩，当时我就是被炫酷的页面和华丽的效果拐入了坑。偏离正轨的回答是：因为除了前端，其他的都不会呀。何况我真的才只进了半只脚。

如果前端的各项技能满级都是 100 级的话，我现在所点亮的大概占 5%，而点亮的这些大概也都只有 5 级。以前写过一些技术向的文章，羞于见人，博客也随之删删改改，从未稳定过。但是现在觉得就算是只有 5 级，也可以写符合 5 级水平的东西，这是思考的过程以及今后宝贵的财富。因此我也正式启用 Github 来托管这个博客，希望能够以此为新的起点，慢慢修炼。

未来 (ง •̀_•́)ง

人类从来都是不知足的动物，我当然不例外，也会幻想有一天，左手 HTML、右手 CSS、脚踏 Javascript、身穿 Node.js、头顶世界上最好的 PHP，在 Web 世界里奔跑，顺手采几朵 xxx.js 来装饰自己。

该醒醒啦 XD

记录 Linux 中踩到的一些坑

Sun, 01 Feb 2015 13:14:24 GMT

本文不定时更新，首次发表于 2015 年 2 月 1 日，最后编辑于 2017 年 1 月 18 日。

2015-02-01

CentOS 中 nginx 的权限

这两天把服务器从 Ubuntu 换成 CentOS，没想到就立刻踩到了奇怪的坑。首先 nginx 安装完成之后服务器 IP 能够正常访问，并显示 nginx 的默认页面；但是当我把配置文件的 root 路径更改之后，访问就变成了 403 Forbidden。此时就算修改路径文件夹的读写权限也不行。最终的解决方案是修改 /etc/nginx/nginx.conf 里 user 的权限值为 root。
修改 SSH 的默认端口之后如何使用 git

git 默认使用 22 端口进行操作，当服务器的该端口被禁用时，我们需要修改一些参数让它继续正常工作，比较简单的解决办法是把远程仓库的 url 手动加上 ssh:// 改为：ssh://username@domain.com:port/path/to/folder.git。
删除全部文件时 zsh 的用户确认

自从几星期之前叛变到 zsh 之后，我就爱上了这个配置快捷简单的漂亮 shell（没错，就是看脸）。但还是踩上了一个“好坑”。 zsh 非常适合新手用户，不仅拥有是强大的自动补全、高亮等功能，它在你删除所有文件时 rm -rf *，都会再一次进行确认，防止误删。可就是这个功能让我纠结了好一会儿。 shell 脚本里面因为包含 rm -rf * 而无法执行成功。其实还是自己手贱把脚本里原先的 #!/bin/bash 改成 #!/bin/zsh 所导致，改回去就 OK 了。

2015-02-05

使用显卡专有驱动之后无法进入桌面

昨天重装电脑，本想使用 nvidia-331 专有驱动来切换显卡以解决机器发烫的问题，但是却无法登出，重启之后也无法登录。搜寻之后发现是 Gnome 使用了 gdm 作为登录管理器的原因。解决方法是使用 lightdm 取代之：sudo apt-get install lightdm，安装的时候注意选择，重启之后就能登录了。~~但界面没有 Unity 优化得好看。~~ 此外，因为 Ubuntu Unity 默认使用 lightdm 作为登录管理器，所以以前使用的时候没有遇到这个坑。

2015-03-05

gulp 监控文件数量限制

在用 gulp 启动项目的时候，发现只有 watch 的 task 无法被正常启动，这是 Linux 的限制所导致。因为是装的 Arch Linux，所以可能在这方面没有像 Ubuntu 一样有自动优化（瞎猜的，不深究）。解决方法见链接，直接调成最大值即可（grunt 同理）：Grunt watch error - Waiting…Fatal error: watch ENOSPC

2015-03-12

Chrome 标签页切换以及输入卡顿

用 Ubuntu 的时候 Chrome 好好的，换了 Arch 就出现各种问题，就一个感觉，特别卡：打字卡、标签页切换卡、总之就是卡。昨天偶然看到一片文章，才发现了问题所在，原来最终的根源并不是我，原来界面字体需要是非本地化的无衬线字体，详见：http://suselinks.us/how-to-fix-slow-typing-in-chrome-addressbar-in-linux/ 。修改之后再次运行如飞。随着版本的更新，这个 bug 最终将会被修复，权当学习之旅上的点滴记录了。

2015-04-11

文本和终端字体太细

安装了很多不同的发行版和桌面环境，除了 Unity 以外，其他所有的文本和终端字体都很细，改字体之类的也没有用。然后发现是渲染问题，其他的需要安装额外的软件包 Infinality，字体瞬间变清晰好看！

2017-01-18

zsh 启动时间太长

自从 2015 年 5 月份开始用 macOS 之后，基本不怎么折腾东西。只是最近实在无法忍受慢成狗一样的 shell。其实对于我来说，有两样东西限制了 zsh 的启动速度：1. 大部分 zsh 用户都会安装的 oh-my-zsh；2. 大部分 node 用户都会使用的版本管理工具 nvm。禁用之后一切安好。好了，其实这次是来安利另一个 shell => fish 的，自带各种补全和主题，确实如介绍所说是 user friendly，而且秒开！