时之碎片

说明

本人以拙劣的文笔和对计算机粗浅的理解，写下了这篇文章。
（该文风格模仿了侯世达先生的《GEB》）
注：文章中 GOC 表示“计算机神灵”，ACB 表示“笨拙的初学者”，UIT 表示下文说到的可以解释一切的机器。

正文

ACB: 好久不见啊，尊敬的 GOC。

GOC: 不用这么拘谨，今天的天气不错啊，这次来找我什么事？

ACB: 您还是一如既往的喜欢晴天呢，这次我来是想请教一下理发师悖论。

GOC：理发师悖论？

ACB: 没错，理发师悖论，就是说从前有个理发师说他只给不给自己理发的人理发。

GOC: 啊，这个我知道。但是你知道么，你问了个愚蠢的问题，这种问题往往只是文字游戏罢了。自己给自己理发不是一件很愚蠢的事吗？天啊，怎么会有人自己给自己理发？

ACB: 那我换个说法，用数学语言来描述吧。

GOC: 数学？说实话我不太喜欢数学家。

ACB: 但是我们得承认他们的确很聪明。

GOC: 这倒是。

ACB：用数学语言大概应该这么描述：“S={x|x ∉ x}”

GOC: 这么看倒是悖论，不过那些聪明的数学家肯定已经解决这个问题了。

ACB: 的确，不过他们解决的办法显得不是那么的“聪明”。他们把对象区分开了，像是自然而然地那样。

GOC: 我想你说的是 Type Theory？

ACB: 没错，他们把一切都分开了，这样一来就不会产生自己包含自己这种荒谬事情发生了。他们弄了一条公理（正则性）“如果 A 是一个非空的集合，那么至少 A 含有一个元素 x,它要么不是集合，要么与 A 不相交的集合。”（注：该公理也称为基础公理（foundation axiom））

GOC：他们解决的不错，不过我对这种问题厌烦了。就如同和尚讲故事一样。

ACB：和尚讲故事？

GOC: 对啊，你没听过那个著名的故事吗？

     从前有座山，山里有个庙，庙里有个老和尚给小和尚讲故事

        从前有座山，山里有个庙，庙里有个老和尚给小和尚讲故事

                从前有座山，山里有个庙，庙里有个老和尚给小和尚讲故事
                                 …….

（过了大概有几分钟）

ACB: 那个，其实我也对和尚讲的故事不太感兴趣。

GOC: 我也说烦了，不如去我家歇一会把，我也想回去喝点水。正好给你看看我收到的一个有趣的新玩艺。

ACB：有趣的新玩艺？

GOC: 嗨，别提了。那天我正在我家地下室打扫卫生，忽然听到有人敲门，我问了半天也没人回答。后来我开门一看发现一个大盒子摆在了门口，上面还贴着一张纸条

“这个机器可以解释一切问题”
         —无名氏献上

ACB：解决一切问题？那可真是有点怪，我还从来没听说过有人开发出了这种机器。

GOC：不过就像方便面的包装一样，我从来不相信包装上的任何东西。

ACB: 我觉得你是对的，但这种神奇的东西我也想要见识见识。

GOC: 我们已经到了，我把那台机器放在了地下室，这东西或许能让你大吃一惊。

ACB：光看到这个机器我就已经大吃一惊了。你是怎么把它搬到地下室的？

（指了指那台几乎占满整个地下室的机器）

GOC:嗨，那可差点累死我。不过先别说那个了，让我们先来打开这个机器。（说着按下了机器按钮，那台巨大的机器开始运作并发出了巨大的轰鸣声）

GOC: 这破机器每次运行都要这么大噪音吗？我现在倒是很担心家里的电费怎么办。

ACB: 这应该是风扇的声音。（一股热浪向两人袭来）

GOC：我觉得冬天开着这台机器都不用烧炉子，但是电费……诶，好了，现在可以问问题了。

ACB: 这东西真的能解释一切问题吗？

GOC: 大概吧，或许你可以自己试试。我先去喝点茶。

ACB: 好吧，那我试一试。

UIT: 你好，你有什么问题？

ACB: 嗯，我想想，你到底是什么？

UIT：如你所见我就是 UIT，我可以解释一切问题。

ACB: 虽然我觉得这不算回答……那，你能帮我解释一下哥德尔不完备定律吗？

UIT: 没问题。(它给出了完整的回答)

（过了大概一个小时，GOC 回到了地下室）

GOC: 你不会还在和这台机器玩游戏吧，我觉得我该把它关了，我可不想明天早上收到电费催缴单。

ACB: 快了，这台机器知道的还不少呢，看上去真像送来这个东西的那个人写的一样。

ACB: 我再问它最后一个问题，你看上去的确比大多数人都要聪明啊，不过我很好奇，你该怎么解释你是如何解释一切的吗？

GOC: 说实话，我觉得你又提了个愚蠢的问题。

UIT: ……

UIT: ……

UIT: ……

ACB: 这机器坏了吗？怎么突然没反应了？

（啪的一声，地下室的灯灭了，机器也停了下来）

GOC: 天啊怎么回事，好像停电了？我去看看地下室的电闸。（说着变戏法一样的掏出了一个手电筒。）

GOC: 我看看，电闸跳闸了。说实话兄弟，我觉得你今天总是提出一些愚蠢的问题。

ACB: 的确是这样，我很抱歉。我能帮上什么忙吗？

GOC：我觉得把电闸推回去就行。（说着推了下电闸）

(地下室的灯又亮了起来)

GOC: 让我看看这台机器。（说着又按下机器按钮）

(过了两分钟，没有丝毫的动静)

ACB: 我很抱歉，看起来我弄坏了这台机器。

GOC: 不是我说，你不能总是提这种愚蠢的问题，尽管你是初学者。现在看来我得修修这台机器了，我才发现这箱子里根本没有保修单啊。

ACB: 难不成这是个三无产品？

GOC：你好像机敏了一些，就现在来看，你是正确的。

ACB: 或许我能帮上些什么忙？

GOC: 或许你可以帮我带晚饭？这台见鬼的机器不知道什么时候能修好。这样，离着两公里远有一家川菜馆，你或许可以给我带点不辣的川菜回来。

ACB: 不辣的川菜？

GOC：对，这是他们家的招牌，不辣的川菜。

ACB：好吧，这还真是奇怪，真是抱歉给你添麻烦了，我去去就回。

（ACB 觉得在这个地下室里的确很不自在，于是赶快离开了）

任何非常先进的技术，初看都与魔法无异。

高阶函数

高阶函数是什么？在第一次遇见这个名词的时候，我还以为是封装好的轮子，只是可以实现的功能比较强大，然而其实际的含义可以解释为\

• 接受一个或多个函数作为输入

• 输出一个函数

  满足上述两个条件之一便可称之为高阶函数

例如我们要构建一个数学上的 Σ 符号（求和符号），可能有人觉得这有什么难的？然后给出下面这种代码

1
2
3
4
5
6
7
8

int a[10000];
int sum(int n,int *a){
   int result;
   for(int i = 0;i<n;i++){
       result += a[i];
   }
   return result;
}

这个函数却可以做到求和，但是如果我现在想求 n^2 的和怎么办呢？

1
2
3
4
5
6
7
8

int a[10000];
int sum(int n,int *a){
   int result;
   for(int i = 0;i<n;i++){
       result += pow(a[i],2);
   }
   return result;
}

好吧，但是我又想求 n^3 的和怎么办呢？就你事多

突然你的同事过来告诉你：“好吧，技术部门搞错了，他们其实想要的是平方和”

这个时候你可能已经打算举起手中键盘了，但是等等，你不觉得这样写求和函数代码根本没有复用性吗？如果我的求和函数又要更改步长怎么办？如果需求再次变动怎么办？当代码比较少的时候你可能还能找到令你抓狂的求和函数并修改它，一旦程序的复杂性增长，你每次变动程序都有可能带来灾难性的后果。这个时候你可能会想到面向对象编程（oop），但是我们今天不讨论这个，我们试图用高阶函数来解决这个问题。 作者：菌汤锅好吃

额，这个看上去够丑的，那些个函数指针是什么？我们为什么要构建这么丑的一个函数？这个函数（过程）已经很好的抽象出了数学符号 ∑ start 与 end 分别代表了上下界，next,term 两个函数（过程）分别表达了步长和操作，这样一来每次需求变化时我只要改动 sum 的参数就行了，根本不用再次修改底层的 sum 代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include<stdio.h>
int next(int i) {
   //下一个迭代;
   i += 1;
   return i;
}
int square(int n) {
   n = n * n;
   return n;
}
int next2(int i) {
   i += 2;
   return i;
}
int term2(int n) {
   n = n * 2;
   return n;
}
double sum(int start, int end, int(*next)(int a), int(*term)(int b)) {
   static int result = 0;
   if (start <= end) {
       result += term(start);
       return sum(next(start), end, (*next), (*term));
   }
   else
       return result;
}
int main(){
   int a, b;
   scanf("%d %d", &a, &b);
   printf("%f",sum(a, b, next2, term2));
   printf("%f",sum(a, b ,next1, term1));
   return 0;
}

一道小题

题目内容

在本讲中，我们讲了 RISC 计算机的基本思想。事实上，人们可以设计出只有一条指令的计算机，这种计算机称为单指令计算机 （Single Instruction Computer，SIC） 。因为只有一条指令，指令集不能再精简，所以这种计算机也称为终极精简指令集计算机 （Ultra Reduced Instruction Set Computer，URISC） 。
这条唯一的指令有三个操作数，每个操作数均为一个存储单元地址，指令的功能是对前两个存储单元中的操作数做减法，将结果写入 第二个操作数 所指的存储单元中。如果减法的结果小于 0，则发生跳转，执行第三个操作数所指向的存储单元中的指令，否则；继续执行后继指令。
因为只有一条指令，所以不需要操作码，因此该指令的格式如下：

1

[L:] a, b, c ; mem[b] = mem[b] - mem[a]，if (mem[b] < 0) goto c

其中，L 为可选的标号，“；” 后面是注释，此处实际上是对该指令功能的形式化描述。
尽管 URISC 只有一条指令，但是它是一种通用计算机，也就是说用这一条指令可以编写出实现任何复杂算法的程序。
例如，将地址为 SRC 的存储单元中的内容传送到地址为 DEST 的存储单元中。可以编写出如下程序：

1
2
3
4
5
6

START: DEST, DEST, ADD
ADD : SRC, TEMP, NEXT
NEXT: TEMP, DEST, CONT
CONT: …
…
TEMP: WORD 0

其中，WORD 是伪指令，用于将指定的内存单元初始化为指定的常数。
根据以上说明，完成如下题目：

编写一段 URISC 程序，将 a 和 b 相加，结果写入 a 中，b 保持不变。

编写一段 URISC 程序，将 a 和 b 相乘，结果写入 c 中。约定存储单元 one 包含常数 1，a 和 b 均大于 0，并且 a 和 b 可以被程序修改。

请提出一个设计方案，用硬件实现 URISC 计算机。你只需提出顶层设计，可以不考虑电路细节。

（选做）编写一个 C/C++ 程序，对 URISC 的功能进行仿真。

作答思路
这道题主要考察的还是一种数学上的思维，并不考察具体的计算机技术（让人莫名想到皮亚诺公理）
由于本人对硬件不太了解所以做做 1，2，4 问，这篇先写一二问（第四个以后填坑）

第一问的内容思路很清晰，从题目叙述就能知道，这个所谓的 ultra 指令集只支持减法，但是支持负数的存储（应该是补码形式）那么我们只要构建相应的减去负数即可了。

第二问的就是在加法的基础上构建出乘法，思路是一样的。(构建循环)

第一问

1
2
3
4

START: TEMP, TEMP, L1 ; TEMP = 0
L1: b, TEMP, L2 ; TEMP = -b
L2: TEMP, a, END ; a = a - TEMP
END

第二问

1
2
3
4
5
6
7
8
9
10

START: c, c, T1 ; c = 0
T1: pone, pone, T2 ; pone = 0
T2: one, pone, S1 ; pone = -1
S1: b1, b1, S2 ; b1 = 0
s2: b, b1, L1 ; b1 = -b
L1: TEMP, TEMP, L2 ; TEMP = 0
L2: a, TEMP, LOOP ; TEMP = -a
LOOP: TEMP, c, j ; c -= TEMP
j: pone, b1, LOOP ; jump
END

写的好丑

这和计算机有什么关系？

小明的舅舅是谁？突然问这个问题恐怕所有人都会一头雾水，大多数人的第一反应恐怕是：小明是谁？？？
这个问题实在让人烦躁。这个家伙上来就问我小明的舅舅是谁，可我连小明是谁都不知道，这人怕不是失了智。好吧，我们换个问题。

什么是计算机程序？

有些人可能会毫不犹豫地说 lambda 算子就是程序，也有些人可能说对计算机硬件的可预先设定的操作就是程序。这两个说法都没有问题，维基百科上给出的解释是这样。

A computer program is a collection of instructions that performs a specific task when executed by a computer. A computer requires programs to function

我们今天可以看看另一种风格的“程序”

prolog

这是一门不同的语言，它没有赋值，也没有传统意义上的函数。它有的只是陈述性语句和待求解的问题。这是个例子：

这并不像是程序而像一份声明清单，而 prolog 恰恰是以一阶谓词为基础的逻辑性语言（program in logic）（个人认为，这某种程度上也限制了它的应用场景）prolog 求解问题的方是还是十分暴力的，主要是匹配和回溯。
例如上述问题，prolog 是如何处理的呢？其步骤如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.找到第一个问题 uncle(a,U)
2.进行事实匹配
father(a,b).
father(c,d).
father(a,c).
均不符合。
3.规则匹配有
brother(a,Z),father(Z,U)
4.再分为两个问题
brother(a,Z)与 father(Z,U)
进行匹配
5.brother(a,Z)
可以匹配到
brother(a,c).
故有：{c/Z} （注：类似于变量替换）
6.代入进第二个问题
father(c,U)
7.寻找事实
father(c,d)符合
可得{d/U} 8.解为 d 即 a 是 d 的叔叔

可以看出 prolog 处理问题比较死板，其逻辑又相似于 sql 之类的数据库语言（事实上其变种语言的确应用在了数据库上）然而其程序编写的难度对新手的确极不友好但学习这种这种语言也给我们提供了另一种看待程序语言的思路（或者说看待程序的思路）
这篇博客只是简要介绍了 prolog 的基本思路，prolog 中还有很多其他技巧，如果感兴趣可以慢慢探索。

三原色光模式(RGB)

三原色模式应用极其广泛，这种模式通过红，绿，蓝三个颜色通道的变化以及叠加来形成各种不同的颜色。但 RGB 依赖于设备，即不同的设备对同一个 RGB 值的检测与重现可能不同。

三原色模式为相加原色（加法混合）

三原色的表示

数值表示

使用用一个三维向量来描述，大多使用八位十六进制数来表示。例如：用 66ccff 来表示天蓝色$
每两位十六进制数表示一个分量（r,g,b）
当然一些土豪的高级设备会使用更大的数值范围来描述颜色

印刷四分色（CMYK）

顾名思义，这种色彩模式用于全彩印刷，四种标准颜色分别为青色（C-Cyan），洋红（M-Magenta），黄色（Y-Yellow），黑色（B-Black）

CMYK 混合

与 RGB 相反，CMYK 是减法混合模式，CMY 三种颜色混合后会产生深灰色。

HSL 与 HSV(HSB)色彩空间

HSL 与 HSV 均把 RGB 的点转换为圆柱坐标系中表示，这样更加直观。
HSL 为色相、饱和度、亮度。HSV 为色相、饱和度、明度。

色相、饱和度、亮度（明度）

-色相（H）：色彩的基本属性，就是我们日常生活中所说的颜色。红色，黄色等。

-饱和度：色彩的纯度饱和度越高色彩越纯，越低就越加变灰。

-亮度（明度）：顾名思义,取值从 0%~100%。

HSL 与 HSV 比较

HSV 在 Adobe 系列中常用，而 HSL 应用于 CSS3 规定。

在 HSL 中，饱和度分量总是从完全饱和色变化到等价的灰色（在 HSV 中，在极大值 V 的时候，饱和度从全饱和色变化到白色，这可以被认为是反直觉的）。

在 HSL 中，亮度跨越从黑色过选择的色相到白色的完整范围（在 HSV 中，V 分量只走一半行程，从黑到选择的色相）。

YUV（Y’CbCr）

YUV 发明于黑白电视与彩色电视的过渡时期。黑白视频只有 Y 视频（灰阶值）。YUV 的颜色编码模式常用于流媒体其中 U 表示色度 V 表示明度。而 Y’CbCr 是 YUV 的压缩版本，Y’CbCr 常用于数字图像领域，YUV 常用于模拟信号领域。

formats 格式：
紧缩格式：将 YUV 的值存储成 Macro Pixels 数组，与 RGB 存放类似。

平面格式：将 YUV 三个分量存放在不同的矩阵中。
注：Macro Pixels 数组即宏像素。

Lab 色彩空间

Lab 色彩空间中 L 代表亮度，a 和 b 表示颜色对立维度。
Lab 颜色被设计接近于人类视觉,致力于感知均匀。在 ps 中图像编辑有“Lab 模式”，PDF 使用的也是“Lab 色彩空间”。

_开始念动咒语吧！_

古老的魔法

从某种意义上讲，写程序和念咒语是没什么区别的。不信你看：

1
2

int number  =  5;
number ++;

例如上面这个 c 语言程序片段，我们念动咒语 int number = 5 就把 5 赋值给了 number，这好比念动咒语让帽子里出现鸽子。魔法师是分派别的，他们念动的咒语不同，效果也不用。写程序也是如此，程序编写者使用的语言不同，就好像念动不同派别的咒语。在辉煌的程序语言家族里，有一门较为古老的语言，lisp。这个系列要了解的就是它的一门方言 scheme，让我们先来看看这们语言的基础吧：

1
2
3

>(display "Hello Scheme!")
Hello Scheme!
>

（注：关于法杖（开发环境）的获取，网络上有许多经验，故不再赘述）
这门古老的语言和一般的语言不太相同，例如最基本的表达式：

1
2
3
4
5
6

>(3 + 4)
application: not a procedure;
expected a procedure that can be applied to arguments
given: 3
arguments...:
>

额，看来我们念错了咒语。（还好没被吸进魔法书里）我们看看计算机向我们抱怨了什么，它说这并不是一个过程，现在需要一个过程来应用于参数上。看来计算机认为我们输入的（3 + 4）是参数。其实正确的咒语是这样的：

1
2
3

>(+ 3 4)
7
>

这也可以理解，不过就是把加法应用在 3 和 4 上，也没什么复杂的嘛！其他的基本运算也是如此：

1
2
3
4
5
6
7
8
9
10
11

>(+ 3 4)
(* 3 4)
(- 3 4)
(/ 3 4)

7
12
-1
3
—
4

看起来还都不错，除了最后一个，那是什么？这个东西太诡异了吧，仔细看看好像是分数？等等，你别骗我，计算机可不能搞出来分数。我知道 IEEE754！别想骗我！是的，计算机本身不能表示分数（其实你也可以强行搞，得不偿失），但是不代表我们不能弄出分数结构对不对？
我猜你肯定在想这个吧？

1
2
3
4
5

>(/ 2 4)
1
—
2
>

嘿嘿，事情并不像你想的那样吧，显然我们完全可以用分数进行计算，这就像 1+1 = 2 （当然这是十进制加法，皮亚诺公理下的）一样。我们再试试这样？：

1
2
3
4
5

>(+ 6 3/4)
   3
 6 —
   4
>

(当然这个比例不太对，但是结果的结构是正确的)能看得出来这是带分数，下面我们看看小数：

1
2
3

>(* 0.43 0.7)
0.301
>

不错，scheme 直接计算小数乘法还是不错的，不如我们再做一些好玩的事？

1
2

>(+ 9999999999999999999999999999 233333333333333333333333333)
10233333333333333333333333332

你在干什么！机器会被你玩坏的！额，但是看上去好像一点问题都没有啊。对了，我们在念动咒语的时候并不像 c 那样要念出我们要召唤精灵的名字(int,char,double,float…)我们直接进行了计算，可见 scheme 不像 c 语言那样是静态类型而是动态类型。所以我们也不用担心 Int 的溢出问题了。
刚才我们试的所有式子都是(operator exp exp)的形式，我们不如试试别的？

1
2

>(+ 0.321 0.32143 0.5634)
1.2058300000000002

这不对啊，这根本不是他们算出来的结果啊。虽然 scheme 的小数可以直接输入操作，但如同 c 中的 float,double 一样有精度的限制。（IEEE754）
这节我们了解了基础的运算和一些规则，但是我们还没有掌握其他的一些必要工具，我们将在下节中介绍。

_任何非常先进的技术，初看都与魔法无异。_

λ-calculus

这篇博客我们简单说说 λ-calculus。
在 λ 演算中，每个表达式均代表一个函数，这个函数有一个参数，并返回一个值。故 λ 演算只有一种“类型”，即单参函数。（这也是为什么上一篇博客里说柯里化给予 λ 演算一个理论模型）而函数由 λ 表达式匿名定义，如：f(x) = x * 2
可以写为 λx.x * 2 而 f(4)的值即可表示为(λx.x * 2) 4。
看上去怪怪的，突然冒出来一个孤零零的数字 4，如果有强迫症的话简直不能忍啊！那么我们还可以把它写成下面这个样子：
(λf.f 4)(λ.x x * 2)这回看着规整了一些。(λf.f 4)表示的是这个函数接受一个函数作为参数，并作用在 4 上。
就如同任何编程语言都有语法一样，λ 演算也需要语法。λ 演算将符合这些语法的表达式也称作“lambda 项”其语法可归纳成三条规则：

• 变量 x 本身就是一个有效的 lambda 项
• 如果 t 是一个 lambda 项，而 x 是一个变量，则(λx.t) 是一个 lambda 项（称为 lambda 抽象）
• 如果 t 和 s 是 lambda 项，那么(ts)是一个 lambda 项（称为应用）
  等等，这样一来，我写下这种式子(λx.x x)(λx.x x)也是对的，但是貌似计算不出来一个确定的值啊。然而这是可以接受的，因为 lambda 表达式并不要求必须归约到一个确定的值上。
  接下来我们来看一个有趣的东西：

Church 数

Church 数 0, 1, 2, …在 lambda 演算中被定义如下：

1
2
3
4
5
6
7

0 ≡ λf.λx. x
1 ≡ λf.λx. f x
2 ≡ λf.λx. f (f x)
3 ≡ λf.λx. f (f (f x))
...
n ≡ λf.λx. fn x
...

这是什么？怎么凭空就能冒出来 0 ≡ λf.λx. x，1 ≡ λf.λx. f x 这种奇怪的东西？我们先回想一下自然数是怎么定义的？
额，像是 0，1，2，3······这种数叫自然数？这种定义太不严谨，我们要用皮亚诺公理定义自然数：

• 0 是一个自然数。
• 0 不是任何其他自然数的继数。
• 每一个自然数 a 都有一个继数。
• 如果 a 与 b 的继数相等则 a 与 b 亦相等。
• 若一个由自然数组成的集合 s 包含有 0，又若当 s 包含有某一数 a 时，它一定也含有 a 的继数，则 s 就包含有全体自然数。
  看上去好多了，但是这又和上面的 church 数有什么关系呢？我们可以这么理解：
  我们先定义了一个零作为基础，又定义了后继这个概念（计算方法），我们现在只不过在用 λ 表达式来表示罢了，其中的 f 就可以理解为后继。这倒是能说得通，但是我要做加法又怎么理解？很简单，只不过是进行多次后继罢了。
  
  
  正真的 λ 演算比本文所描述的要复杂很多，本文只是简要的介绍。

_任何非常先进的技术，初看都与魔法无异。_

currying

currying(柯里化)将函数转化成单参函数，即将所有函数固定为接受一个参数，返回一个值的形式。给予 λ 演算一个理论模型。


而柯里化究竟是什么呢?我们可以这么理解，例如现在我们有一个二元函数f(x,y) = x + y 那么在代码里可以这么书写：

1
2
3

int add(int a, int b){
    return a + b;
}

甚至没学过计算机的人都能看懂它的含义，取两个数 a,b 在进行相加运算后返回结果。但我们应当注意的是，这个函数传进去的只能是两个参数，否则机器将无法工作。更重要的是这个函数返回的是一个数值。


而柯里化的方式是什么呢？柯里化要把这个函数改造为单参函数。逻辑上如下图所示

该图上面是正常的 add，下面是柯里化的 add。


我们相当于构建了两个“机器”每个“机器”只做有限的工作，剩下的工作交给下一个“机器”，这样我们可以把复杂的“机器”拆分成一系列的小型“机器”。


柯里化给我们理清了一个思路，类似于用皮亚诺公理解释自然数，我们可以用这种简单的函数（过程）模型来构建出强大的系统。但是这个理论在实际应用上貌似并不多，至少在我所触及的范围内几乎没有用过。

注：由于笔者的水平有限，文章中可能存在疏漏。

Lorem ipsum

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

test test test

“中文”

$a^{2} + b^{2} = c^{2}$
$\infty, \aleph, \complement, \backepsilon, \eth, \Finv, \hbar$
$s_k \equiv 0 \pmod{m}$
$\cup, \Cup, \sqcup, \bigcup, \bigsqcup, \uplus, \biguplus$
$\lim_{x \to \infty} \frac{1}{n(n+1)}$
わたぃ
リンゴ
ビル

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

hexo new "My New Post"

More info: Writing

Run server

1

hexo server

More info: Server

Generate static files

1

hexo generate

More info: Generating

Deploy to remote sites

1

hexo deploy

More info: Deployment