墨辯：中文邏輯語言

墨辨主架構

2016-06-28T23:12:00.000-07:00

墨辨直譯器
墨辨IDE

被動式

2016-03-08T01:47:00.000-08:00

語言為何要有被動式，動作是句子述語的主要部分，動作有發動者及接受者之分，若發動者不重要，我們使用被動式省略發動者，強調動作接受都。

我被親了。被誰親不重要。

Scheme 語言概要

2014-01-01T16:32:00.002-08:00

简介： Scheme语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。

作为Lisp 变体，Scheme 是一门非常简洁的计算语言，使用它的编程人员可以摆脱语言本身的复杂性，把注意力集中到更重要的问题上，从而使语言真正成为解决问题的工具。本文分为上、下两部分来介绍 scheme 语言。

一．Scheme语言的特点

Scheme语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。

它是一个小巧而又强大的语言，作为一个多用途的编程语言，它可以作为脚本语言使用，也可以作为应用软件的扩展语言来使用，它具有元语言特性，还有很多独到的特色,以致于它被称为编程语言中的"皇后"。

下面是洪峰对Scheme语言的编程特色的归纳：

词法定界（Lexical Scoping）
动态类型（Dynamic Typing）
良好的可扩展性
尾递归（Tail Recursive）
函数可以作为值返回
支持一流的计算连续
传值调用（passing-by-value）
算术运算相对独立

本文的目的是让有编程基础（那怕是一点点）的朋友能尽快的掌握Scheme语言的语法规则，如果您在读完本文后，发现自己已经会用Scheme语言了，那么我的目的就达到了。

回页首

二．Scheme语言的标准与实现

R5RS (Revised(5) Report on the Algorithmic Language Scheme)

Scheme语言的语法规则的第5次修正稿，1998年制定，即Scheme语言的现行标准，目前大多数Scheme语言的实现都将达到或遵循此标准，并且几乎都加入了一些属于自己的扩展特色。

Guile (GNU's extension language)

Guile是GNU工程的一个项目，它是GNU扩展语言库，它也是Scheme语言的一个具体实现；如果你将它作为一个库打包，可以把它链接到你的应用程序中去，使你的应用程序具有自己的脚本语言，这个脚本语言目前就是Scheme语言。

Guile可以在LINUX和一些UNIX系统上运行，下面是简单的安装过程：

下载guile-1.6.4版，文件名为guile-1.6.4.tar.gz，执行下面的命令：

tar xvfz guile-1.6.4.tar.gz
cd guile-1.6.4
./configure
make
make install

如此，即可以执行命令guile，进入guile>提示符状态，输入调试Scheme程序代码了，本文的所有代码都是在guile下调试通过。

其它实现

除了Guile外，Scheme语言的实现还有很多，如：GNU/MIT-Scheme， SCI，Scheme48，DrScheme等，它们大多是开源的，可以自由下载安装使用，并且跨平台的实现也很多。你会发现既有象basic的Scheme语言解释器，也有将Scheme语言编译成C语言的编译器，也有象JAVA那样将Scheme语言代码编译成虚拟机代码的编译器。

三．基本概念

注释

Scheme语言中的注释是单行注释，以分号[;]开始一直到行尾结束，其中间的内容为注释，在程序运行时不做处理，如：

  ; this is a scheme comment line.

标准的Scheme语言定义中没有多行注释，不过在它的实现中几乎都有。在Guile中就有多行注释，以符号组合"#!"开始，以相反的另一符号组合"!#"结束，其中内容为注释，如：

#!
there are scheme comment area.
you can write mulity lines here . 
!#

注意的是，符号组合"#!"和"!#"一定分做两行来写。

Scheme用做脚本语言

Scheme语言可以象sh，perl，python等语言那样作为一种脚本语言来使用，用它来编写可执行脚本，在Linux中如果通过Guile用Scheme语言写可执行脚本，它的第一行和第二行一般是类似下面的内容：

#! /usr/local/bin/guile -s
!#

这样的话代码在运行时会自动调用Guile来解释执行，标准的文件尾缀是".scm"。

块(form)

块(form)是Scheme语言中的最小程序单元，一个Scheme语言程序是由一个或多个form构成。没有特殊说明的情况下 form 都由小括号括起来，形如：

(define x 123)
(+ 1 2)
(* 4 5 6)
(display "hello world")

一个 form 也可以是一个表达式，一个变量定义，也可以是一个过程。

form嵌套

Scheme语言中允许form的嵌套，这使它可以轻松的实现复杂的表达式，同时也是一种非常有自己特色的表达式。下图示意了嵌套的稍复杂一点的表达式的运算过程：

变量定义

可以用define来定义一个变量，形式如下：
(define 变量名值)

如： (define x 123) ，定义一个变量x，其值为123。

更改变量的值

可以用set!来改变变量的值，格式如下：
(set! 变量名值)

如： (set! x "hello") ，将变量x的值改为"hello" 。

Scheme语言是一种高级语言，和很多高级语言(如python，perl)一样，它的变量类型不是固定的，可以随时改变。

四．数据类型

1. 简单数据类型

逻辑型(boolean)

最基本的数据类型，也是很多计算机语言中都支持的最简单的数据类型，只能取两个值：#t，相当于其它计算机语言中的 TRUE；#f，相当于其它计算机语言中的 FALSE。

Scheme语言中的boolean类型只有一种操作：not。其意为取相反的值，即：

  (not #f) => #t
  (not #t) => #f

not的引用，与逻辑非运算操作类似

guile> (not 1)
#f
guile> (not (list 1 2 3))
#f
guile> (not 'a)
#f

从上面的操作中可以看出来，只要not后面的参数不是逻辑型，其返回值均为#f。

数字型(number)

它又分为四种子类型：整型(integer)，有理数型(rational)，实型(real)，复数型(complex)；它们又被统一称为数字类型(number)。

如：复数型(complex) 可以定义为 (define c 3+2i)
实数型（real）可以定义为 (define f 22/7)
有理数型（rational）可以定义为 (define p 3.1415)
整数型(integer) 可以定义为 (define i 123)

Scheme语言中，数字类型的数据还可以按照进制分类，即二进制，八进制，十进制和十六进制，在外观形式上它们分别以符号组合 #b、 #o、 #d、 #x 来作为表示数字进制类型的前缀，其中表示十进制的#d可以省略不写，如：二进制的 #b1010 ，八进制的 #o567，十进制的123或 #d123，十六进制的 #x1afc 。

Scheme语言的这种严格按照数学定理来为数字类型进行分类的方法可以看出Scheme语言里面渗透着很深的数学思想，Scheme语言是由数学家们创造出来的，在这方面表现得也比较鲜明。

字符型(char)

Scheme语言中的字符型数据均以符号组合 "#\" 开始，表示单个字符，可以是字母、数字或"[ ! $ % & * + - . / : %lt; = > ? @ ^ _ ~ ]"等等其它字符，如：
#\A 表示大写字母A，#\0表示字符0，
其中特殊字符有：#\space 表示空格符和 #\newline 表示换行符。

符号型(symbol)

符号类型是Scheme语言中有多种用途的符号名称，它可以是单词，用括号括起来的多个单词，也可以是无意义的字母组合或符号组合，它在某种意义上可以理解为C中的枚举类型。看下面的操作：

guile> (define a (quote xyz))  ;  定义变量a为符号类型，值为xyz
guile> a
xyz
guile> (define xyz 'a)  ; 定义变量xyz为符号类型，值为a
guile> xyz
a

此处也说明单引号' 与quote是等价的，并且更简单一些。符号类型与字符串不同的是符号类型不能象字符串那样可以取得长度或改变其中某一成员字符的值，但二者之间可以互相转换。

2. 复合数据类型

可以说复合数据类型是由基本的简单数据类型通过某种方式加以组合形成的数据类型，特点是可以容纳多种或多个单一的简单数据类型的数据，多数是基于某一种数学模型创建的。

字符串(string) 由多个字符组成的数据类型，可以直接写成由双引号括起的内容，如："hello" 。下面是Guile中的字符串定义和相关操作：

guile> (define name "tomson")
guile> name
"tomson"
guile> (string-length name)  ; 取字符串的长度
6
guile> (string-set! name 0 #\g)  ; 更改字符串首字母(第0个字符)为小写字母g (#\g)
guile> name
"gomson"
guile> (string-ref name 3)  ; 取得字符串左侧第3个字符（从0开始）
#\s

字符串还可以用下面的形式定义：

guile> (define other (string #\h #\e #\l #\l #\o ))
guile> other
"hello"

字符串中出现引号时用反斜线加引号代替，如："abc\"def" 。

点对(pair)

我把它译成"点对"，它是一种非常有趣的类型，也是一些其它类型的基础类型，它是由一个点和被它分隔开的两个所值组成的。形如： (1 . 2) 或 (a . b) ，注意的是点的两边有空格。

这是最简单的复合数据类型，同是它也是其它复合数据类型的基础类型，如列表类型（list）就是由它来实现的。

按照Scheme语言说明中的惯例，以下我们用符号组合 "=>" 来表示表达式的值。

它用cons来定义，如： (cons 8 9) =>(8 . 9)

其中在点前面的值被称为 car ，在点后面的值被称为 cdr ，car和cdr同时又成为取pair的这两个值的过程，如：

(define p (cons 4 5)) => (4 . 5)
(car p)   => 4
(cdr p)   => 5

还可以用set-car! 和 set-cdr! 来分别设定这两个值：

(set-car! p "hello")
(set-cdr! p "good")

如此，以前定义的 p 又变成了 ("hello" . "good") 这个样子了。

列表(list)

列表是由多个相同或不同的数据连续组成的数据类型，它是编程中最常用的复合数据类型之一，很多过程操作都与它相关。下面是在Guile中列表的定义和相关操作：

guile> (define la (list 1 2 3 4 ))
guile> la
(1 2 3 4)
guile> (length la)  ; 取得列表的长度
4
guile> (list-ref la 3)  ; 取得列表第3项的值（从0开始）
4
guile> (list-set! la 2 99)  ; 设定列表第2项的值为99
99
guile> la
(1 2 99 4)
guile> (define y (make-list 5 6))  ;创建列表
guile> y
(6 6 6 6 6)

make-list用来创建列表，第一个参数是列表的长度，第二个参数是列表中添充的内容；还可以实现多重列表，即列表的元素也是列表，如：(list (list 1 2 3) (list 4 5 6))。

列表与pair的关系

回过头来，我们再看看下面的定义：

guile> (define a (cons 1 (cons 2 (cons 3 '()))))
guile> a
(1 2 3)

由上可见，a本来是我们上面定义的点对，最后形成的却是列表。事实上列表是在点对的基础上形成的一种特殊格式。

再看下面的代码：

guile> (define ls (list 1 2 3 4))
guile> ls
(1 2 3 4)
guile> (list? ls)
#t
guile> (pair? ls)
#t

由此可见，list是pair的子类型，list一定是一个pair，而pair不是list。

guile> (car ls)
1
guile> (cdr ls)
(2 3 4)

其cdr又是一个列表，可见用于pair的操作过程大多可以用于list。

 guile> (cadr ls)   ; 此"点对"对象的cdr的car
2
guile> (cddr ls)   ; 此"点对"对象的cdr的cdr
(3 4)
guile> (caddr ls)   ; 此"点对"对象的cdr的cdr的car
3
guile> (cdddr ls)   ; 此"点对"对象的cdr的cdr的cdr
(4)

上在的操作中用到的cadr，cdddr等过程是专门对PAIR型数据再复合形成的数据操作的过程，最多可以支持在中间加四位a或d，如cdddr，caaddr等。

下图表示了由pairs定义形成的列表：

这个列表可以由pair定义为如下形式：

(define x (cons 'a (cons 'b (cons 'c (cons 'd '())))))

而列表的实际内容则为：(a b c d)

由pair类型还可以看出它可以轻松的表示树型结构，尤其是标准的二叉树。

向量（vector）

可以说是一个非常好用的类型，是一种元素按整数来索引的对象，异源的数据结构，在占用空间上比同样元素的列表要少，在外观上：

列表示为： (1 2 3 4)
VECTOR表示为： #(1 2 3 4)
可以正常定义：(define v (vector 3 4 5))
也可以直接定义：(define v #(3 4 5))

vector是一种比较常用的复合类型，它的元素索引从0开始，至第 n-1 结束，这一点有点类似C语言中的数组。

关于向量表（vector）的常用操作过程：

guile> (define v (vector 1 2 3 4 5))
guile> v
#(1 2 3 4 5)
guile> (vector-ref v 0) ; 求第n个变量的值
1
guile> (vector-length v)  ; 求vector的长度
5
guile> (vector-set! v 2 "abc")  ; 设定vector第n个元素的值
guile> v
#(1 2 "abc" 4 5)
guile> (define x (make-vector 5 6))  ; 创建向量表
guile> x
#(6 6 6 6 6)

make-vector用来创建一个向量表，第一个参数是数量，后一个参数是添充的值，这和列表中的make-list非常相似。

我们可以看出，在Scheme语言中，每种数据类型都有一些基本的和它相关的操作过程，如字符串，列表等相关的操作，这些操作过程都很有规律，过程名的单词之间都用-号隔开，很容易理解。对于学过C++的朋友来说，更类似于某个对象的方法，只不过表现的形式不同了。

3. 类型的判断、比较、运算、转换与方法

类型判断

Scheme语言中所有判断都是用类型名加问号再加相应的常量或变量构成，形如：

(类型? 变量)

Scheme语言在类型定义中有比较严格的界定，如在C语言等一些语言中数字0来代替逻辑类型数据False，在Scheme语言中是不允许的。

以下为常见的类型判断和附加说明：

逻辑型：

(boolean? #t) => #t
(boolean? #f) => #t 因为#t和#f都是boolean类型，所以其值为#t
(boolean? 2)  => #f 因为2是数字类型，所以其值为 #f

字符型

(char? #\space) => #t
(char? #\newline) => #t 以上两个特殊字符：空格和换行
(char? #\f)  => #t 小写字母 f
(char? #\;)  => #t 分号 ;
(char? #\5)  => #t 字符 5 ，以上这些都是正确的，所以返回值都是 #t
(char? 5)  => #f 这是数字 5 ，不是字符类型，所以返回 #f

数字型

(integer? 1)  => #t
(integer? 2345) => #t
(integer? -90)  => #t 以上三个数均为整数
(integer? 8.9)  => #f   8.9不整数
(rational? 22/7) => #t
(rational? 2.3)  => #t
(real? 1.2)  => #t
(real? 3.14159) => #t
(real? -198.34)  => #t 以上三个数均为实数型
(real? 23)  => #t   因为整型属于实型
(number? 5) => #t
(number? 2.345) => #t
(number? 22/7) => #t

其它型

(null? '())  => #t  ; null意为空类型，它表示为 '() ，即括号里什么都没有的符号
(null? 5)  => #f
(define x 123)  定义变量x其值为123
(symbol? x)  => #f
(symbol? 'x)  => #t  ; 此时 'x 为符号x，并不表示变量x的值

在Scheme语言中如此众多的类型判断功能，使得Scheme语言有着非常好的自省功能。即在判断过程的参数是否附合过程的要求。

比较运算

Scheme语言中可以用<，>，<=，>=，= 来判断数字类型值或表达式的关系，如判断变量x是否等于零，它的形式是这样的：(= x 0) ，如x的值为0则表达式的值为#t，否则为#f。

还有下面的操作：

(eqv? 34 34)   =>  #t
(= 34 34)      =>  #t

以上两个form功能相同，说明 eqv? 也可以用于数字的判断。

在Scheme语言中有三种相等的定义，两个变量正好是同一个对象；两个对象具有相同的值；两个对象具有相同的结构并且结构中的内容相同。除了上面提到的符号判断过程和eqv?外，还有eq?和equal?也是判断是否相等的过程。

eq?，eqv?，equal?

eq?，eqv?和equal?是三个判断两个参数是否相等的过程，其中eq?和eqv?的功能基本是相同的，只在不同的Scheme语言中表现不一样。

eq?是判断两个参数是否指向同一个对象，如果是才返回#t；equal?则是判断两个对象是否具有相同的结构并且结构中的内容是否相同，它用eq?来比较结构中成员的数量；equal?多用来判断点对，列表，向量表，字符串等复合结构数据类型。

guile> (define v (vector 3 4 5))
guile> (define w #(3 4 5))  ; w和v都是vector类型，具有相同的值#(3 4 5)
guile> (eq? v w)
#f     ; 此时w和v是两个对象
guile> (equal? v w)
#t                  ; 符合equal?的判断要求

以上操作说明了eq? 和equal? 的不同之处，下面的操作更是证明了这一点：

guile> (define x (make-vector 5 6))
guile> x
#(6 6 6 6 6)
guile> (eq? x x)    ; 是同一个对象，所以返回#t
#t
guile> (define z (make-vector 5 6))
guile> z
#(6 6 6 6 6)
guile> (eq? x z)    ; 不是同一个对象
#f
guile> (equal? x z)  ; 结构相同，内容相同，所以返回#t
#t

算术运算

Scheme语言中的运算符有：
+ , - , * , / 和 expt (指数运算)
其中 - 和 / 还可以用于单目运算，如：

(- 4)  => -4
(/ 4)  => 1/4

此外还有许多扩展的库提供了很多有用的过程，

max 求最大 (max 8 89 90 213)  => 213
min 求最小 (min 3 4 5 6 7)  => 3
abs 求绝对值 (abs -7) ==> 7

除了max，min，abs外，还有很多数学运算过程，这要根据你用的Scheme语言的运行环境有关，不过它们大多是相同的。在R5RS中规定了很多运算过程，在R5RS的参考资料中可以很容易找到。

转换

Scheme语言中用符号组合"->"来标明类型间的转换（很象C语言中的指针）的过程，就象用问号来标明类型判断过程一样。下面是一些常见的类型转换过程：

guile> (number->string 123)  ; 数字转换为字符串
"123"
guile> (string->number "456")  ; 字符串转换为数字
456
guile> (char->integer #\a)   ;字符转换为整型数，小写字母a的ASCII码值为96
97
guile> (char->integer #\A)  ;大写字母A的值为65
65
guile> (integer->char 97)  ;整型数转换为字符
#\a
guile> (string->list "hello")   ;字符串转换为列表
(#\h #\e #\l #\l #\o) 
guile> (list->string (make-list 4 #\a)) ; 列表转换为字符串
"aaaa"
guile> (string->symbol "good")  ;字符串转换为符号类型
good
guile> (symbol->string 'better)  ;符号类型转换为字符串
"better"

五．过程定义
过程（Procedure）

在Scheme语言中，过程相当于C语言中的函数，不同的是Scheme语言过程是一种数据类型，这也是为什么Scheme语言将程序和数据作为同一对象处理的原因。如果我们在Guile提示符下输入加号然后回车，会出现下面的情况：

guile> +
#<primitive-procedure +>

这告诉我们"+"是一个过程，而且是一个原始的过程，即Scheme语言中最基础的过程，在GUILE中内部已经实现的过程，这和类型判断一样，如boolean?等，它们都是Scheme语言中最基本的定义。注意：不同的Scheme语言实现环境，出现的提示信息可能不尽相同，但意义是一样的。
define不仅可以定义变量，还可以定义过程，因在Scheme语言中过程（或函数）都是一种数据类型，所以都可以通过define来定义。不同的是标准的过程定义要使用lambda这一关键字来标识。
Lambda关键字

Scheme语言中可以用lambda来定义过程，其格式如下：

(define 过程名 ( lambda (参数 ...) (操作过程 ...)))

我们可以自定义一个简单的过程，如下：

  (define add5 (lambda (x) (+ x 5)))

此过程需要一个参数，其功能为返回此参数加5 的值，如：

     (add5 11) => 16

下面是简单的求平方过程square的定义：

 (define square (lambda (x)  (* x x)))

与lambda相同的另一种方式

在Scheme语言中，也可以不用lambda，而直接用define来定义过程，它的格式为：
(define (过程名参数) (过程内容 …))
如下面操作：

  (define (add6 x) (+ x 6))
  add6
  #<procedure: add6 (x)> 说明add6是一个过程，它有一个参数x
  (add6 23)    => 29

再看下面的操作：

guile> (define fun
                (lambda(proc x y)
                        (proc x y)))
guile> fun
#<procedure fun (proc x y)>
guile> (fun * 5 6)
30
guile> (fun / 30 3)
10

更多的过程定义

上面定义的过程fun有三个参数，其中第一个参数proc也是一个操作过程（因为在Scheme语言中过程也是一种数据，可以作为过程的参数），另外两个参数是数值，所以会出现上面的调用结果。

guile> (define add
                (lambda (x y)
                        (+ x y)))
guile> add
#<procedure add (x y)>
guile> (fun add 100 200)
300

继续上面操作，我们定义一个过程add，将add作为参数传递给fun过程，得出和(fun + 100 200)相同的结果。

guile> ((lambda (x) (+ x x)) 5)
10

上面的 (lambda(x) (+ x x)) 事实上是简单的过程定义，在后面直接加上操作参数5，得出结果10，这样实现了匿名过程，直接用过程定义来操作参数，得出运算结果。

通过上面的操作，相信你已初步了解了过程的用法。既然过程是一种数据类型，所以将过程作为过程的参数是完全可以的。以下过程为判断参数是否为过程，给出一个参数，用 procedure? 来判断参数是否为过程，采用if结构（关于if结构见下面的介绍）：

guile> (define isp
            (lambda (x)
                     (if (procedure? x) 'isaprocedure 'notaprocedure)))
guile> isp
#<procedure isp (x)>
guile> (isp 0)
notaprocedure
guile> (isp +)
isaprocedure

上面的过程就体现了Scheme语言的参数自省（辨别）能力，'0'是数字型，所以返回notaprocedure；而'+'是一个最基础的操作过程，所以返回isaprocedure。

过程的嵌套定义

在Scheme语言中，过程定义也可以嵌套，一般情况下，过程的内部过程定义只有在过程内部才有效，相当C语言中的局部变量。

如下面的代码的最终结果是50：

(define fix 
 (lambda (x y z)
  (define add 
   (lambda (a b) (+ a b)))
  (- x (add y z))))
(display (fix 100 20 30))

此时过程add只在fix过程内部起做用，这事实上涉及了过程和变量的绑定，可以参考下面的关于过程绑定（let，let* 和letrec）的介绍。

过程是初学者难理解的一个关键，随着过程参数的增加和功能的增强，过程的内容变得越来越复杂，小括号也会更多，如果不写出清晰的代码的话，读代码也会成为一个难题。

熟悉了 scheme 基本概念、数据类型和过程（函数）后，下一部分我们来学习 scheme 的结构、递归调用和其他扩展功能。

谈完了 scheme 的基本概念、数据类型和过程，我们接着介绍 scheme 的结构、递归调用、变量和过程的绑定、输入输出等功能。

一．常用结构

顺序结构

也可以说成由多个form组成的form，用begin来将多个form放在一对小括号内，最终形成一个form。格式为：(begin form1 form2 …)

如用Scheme语言写成的经典的helloworld程序是如下样子的：

(begin 
 (display "Hello world!")  ; 输出"Hello world!"
 (newline))    ; 换行

if结构

Scheme语言的if结构有两种格式，一种格式为：(if 测试过程1 过程2)，即测试条件成立则执行过程1，否则执行过程2。例如下面代码：

(if (= x 0) 
(display "is zero")
(display "not zero"))

还有另一种格式：(if 测试过程) ，即测试条件成立则执行过程。例如下面代码：

  (if (< x 100) (display "lower than 100"))

根据类型判断来实现自省功能，下面代码判断给定的参数是否为字符串：

(define fun 
 (lambda ( x )
  (if (string? x)
   (display "is a string")
   (display "not a string"))))

如执行 (fun 123) 则返回值为"not a string"，这样的功能在C++或JAVA中实现的话可能会很费力气。

cond结构

Scheme语言中的cond结构类似于C语言中的switch结构，cond的格式为：

  (cond ((测试) 操作) … (else 操作))

如下是在Guile中的操作：

guile> (define w (lambda (x)
      (cond ((< x 0) 'lower)
           ((> x 0) 'upper)
           (else 'equal))))
guile> w
#<procedure w (x)>
guile> (w 9)
upper
guile> (w -8)
lower
guile> (w 0)
equal

上面程序代码中，我们定义了过程w，它有一个参数x，如果x的值大于0，则返回符号upper，如x的值小于0则返回符号lower，如x 的值为0则返回符号equal。

下载已做成可执行脚本的例程。

cond可以用if形式来写，上面的过程可以如下定义：

guile> (define ff
       (lambda (x)
                    (if (< x 0) 'lower
                            (if (> x 0) 'upper 'zero))))
guile> ff
#<procedure ff (x)>
guile> (ff 9)
upper
guile> (ff -9)
lower
guile> (ff 0)
zero

这在功能上是和cond一样的，可以看出cond实际上是实现了if的一种多重嵌套。

case结构

case结构和cond结构有点类似，它的格式为：

(case (表达式) ((值) 操作)) ... (else 操作)))

case结构中的值可以是复合类型数据，如列表，向量表等，只要列表中含有表达式的这个结果，则进行相应的操作，如下面的代码：

 (case (* 2 3)
  ((2 3 5 7) 'prime)
  ((1 4 6 8 9) 'composite))

上面的例子返回结果是composite，因为列表(1 4 6 8 9)中含有表达式(* 2 3)的结果6；下面是在Guile中定义的func过程，用到了case结构：

guile> (define func
                (lambda (x y)
                        (case (* x y)
                                ((0) 'zero)
                                (else 'nozero))))
guile> func
#<procedure func (x y)>
guile> (func 2 3)
nozero
guile> (func 2 0)
zero
guile> (func 0 9)
zero
guile> (func 2 9)
nozero

可以下载另一个脚本文件 te.scm，参考一下。

and结构

and结构与逻辑与运算操作类似，and后可以有多个参数，只有它后面的参数的表达式的值都为#t时，它的返回值才为#t，否则为#f。看下面的操作：

guile> (and (boolean? #f) (< 8 12))
#t
guile> (and (boolean? 2) (< 8 12))
#f
guile> (and (boolean? 2) (> 8 12))
#f

如果表达式的值都不是boolean型的话，返回最后一个表达式的值，如下面的操作：

guile> (and (list 1 2 3) (vector 'a 'b 'c))
#(a b c)
guile> (and 1 2 3 4 )
4
guile> (and 'e 'd 'c 'b 'a)
a

or结构

or结构与逻辑或运算操作类似，or后可以有多个参数，只要其中有一个参数的表达式值为#t，其结果就为#t，只有全为#f时其结果才为#f。如下面的操作：

guile> (or #f #t)
#t
guile> (or #f #f)
#f
guile> (or (rational? 22/7) (< 8 12))
#t
guile> (rational? 22/7)
#t
guile> (real? 22/7)
#t
guile> (or (real? 4+5i) (integer? 3.22))
#f

我们还可以用and和or结构来实现较复杂的判断表达式，如在C语言中的表达式：

((x > 100) && (y < 100)) 和 ((x > 100) || (y > 100))

在Scheme中可以表示为：

guile> (define x 123)
guile> (define y 80)
guile> (and (> x 100) (< y 100))
#t
guile> (or (> x 100) (> y 100))
#t

Scheme语言中只有if结构是系统原始提供的，其它的cond，case，and，or，另外还有do，when，unless等都是可以用宏定义的方式来定义的，这一点充分体现了Scheme的元语言特性，关于do，when等结构的使用可以参考R5RS。

回页首

二．递归调用

用递归实现阶乘

在Scheme语言中，递归是一个非常重要的概念，可以编写简单的代码很轻松的实现递归调用，如下面的阶乘过程定义：

(define  factoral (lambda (x)
    (if (<= x 1) 1
        (* x (factoral (- x 1))))))

我们可以将下面的调用(factoral 4)，即4的阶乘的运算过程图示如下：

以下为factoral过程在Guile中的运行情况：

guile> (define factoral (lambda (x) (if (<= x 1) 1 (* x (factoral (- x 1))))))
guile> factoral
#<procedure factoral (x)>
guile> (factoral 4)
24

另一种递归方式

下面是一另一种递归方式的定义：

(define (factoral n)
 (define (iter product counter)
  (if (> counter n)
   product
   (iter (* counter product) (+ counter 1))))
 (iter 1 1))
(display (factoral 4))

这个定义的功能和上面的完全相同，只是实现的方法不一样了，我们在过程内部实现了一个过程iter，它用counter参数来计数，调用时从1开始累计，这样它的展开过程正好和我们上面的递归过程的从4到1相反，而是从1到4。

循环的实现

在Scheme语言中没有循环结构，不过循环结构可以用递归来很轻松的实现（在Scheme语言中只有通过递归才能实现循环）。对于用惯了C语言循环的朋友，在Scheme中可以用递归简单实现：

guile> (define loop
      (lambda(x y)
          (if (<= x y)
              (begin (display x) (display #\\space) (set! x (+ x 1))
                 (loop x y)))))
guile> loop
#<procedure loop (x y)>
guile> (loop 1 10)
1 2 3 4 5 6 7 8 9 10

这只是一种简单的循环定义，过程有两个参数，第一个参数是循环的初始值，第二个参数是循环终止值，每次增加1。相信读者朋友一定会写出更漂亮更实用的循环操作来的。

回页首

三．变量和过程的绑定

let，let*，letrec

在多数编程语言中都有关于变量的存在的时限问题，Scheme语言中用let，let*和letrec来确定变量的存在的时限问题，即局部变量和全局变量，一般情况下，全局变量都用define来定义，并放在过程代码的外部；而局部变量则用let等绑定到过程内部使用。

用let可以将变量或过程绑定在过程的内部，即实现局部变量：

guile> let
#<primitive-macro! let>

从上面的操作可以看出let是一个原始的宏，即guile内部已经实现的宏定义。

下面的代码显示了let的用法（注意多了一层括号）：

guile> (let ((x 2) (y 5)) (* x y))
10

它的格式是：(let ((…)…) …)，下面是稍复杂的用法：

guile> (let ((x 5))
         (define foo (lambda (y) (bar x y)))
         (define bar (lambda (a b) (+ (* a b) a)))
         (foo (+ x 3)))
45

以上是Guile中的代码实现情况。它的实现过程大致是：(foo 8) 展开后形成 (bar 5 8)，再展开后形成 (+ (* 5 8) 5) ，最后其值为45。

再看下面的操作：

guile> (let ((iszero?
                (lambda(x)
                (if (= x 0) #t #f))))
        (iszero? 9))
#f
guile> (iszero? 0)  ;此时会显示出错信息

let的绑定在过程内有效，过程外则无效，这和上面提到的过程的嵌套定是一样的，上面的iszero?过程在操作过程内定义并使用的，操作结束后再另行引用则无效，显示过程未定义出错信息。

下面操作演示了let*的用法：

guile> (let ((x 2) (y 5))
       (let* ((x 6)(z (+ x y)))  ;此时x的值已为6，所以z的值应为11，如此最后的值为66
       (* z x)))
66

还有letrec，看下面的操作过程：

guile> (letrec ((even?
                (lambda(x)
                (if (= x 0) #t
                        (odd? (- x 1)))))
            (odd?
                (lambda(x)
                (if (= x 0) #f
                        (even? (- x 1))))))
        (even? 88))
#t

上面的操作过程中，内部定义了两个判断过程even?和odd?，这两个过程是互相递归引用的，如果将letrec换成let或let*都会不正常，因为letrec是将内部定义的过程或变量间进行相互引用的。看下面的操作：

guile> (letrec ((countdown
                (lambda (i)
                (if (= i 0) 'listoff
                        (begin (display i) (display ",")
                                (countdown (- i 1)))))))
        (countdown 10))
10,9,8,7,6,5,4,3,2,1,listoff

letrec帮助局部过程实现递归的操作，这不仅在letrec绑定的过程内，而且还包括所有初始化的东西，这使得在编写较复杂的过程中经常用到letrec，也成了理解它的一个难点。

apply

apply的功能是为数据赋予某一操作过程，它的第一个参数必需是一个过程，随后的其它参数必需是列表，如：

guile> (apply + (list 2 3 4))
9
guile> (define sum
           (lambda (x )
                  (apply + x)))  ; 定义求和过程
guile> sum
#<procedure sum (x)>
guile> (define ls (list 2 3 4 5 6))
guile> ls
(2 3 4 5 6)
guile> (sum ls)
20
guile> (define avg
          (lambda(x)
                 (/ (sum x) (length x))))   ; 定义求平均过程
guile> avg
#<procedure avg (x)>
guile> (avg ls)
4

以上定义了求和过程sum和求平均的过程avg，其中求和的过程sum中用到了apply来绑定"+"过程操作到列表，结果返回列表中所有数的总和。

map

map的功能和apply有些相似，它的第一个参数也必需是一个过程，随后的参数必需是多个列表，返回的结果是此过程来操作列表后的值，如下面的操作：

guile> (map + (list 1 2 3) (list 4 5 6))
(5 7 9)
guile> (map car '((a . b)(c . d)(e . f)))
(a c e)

除了apply，map以外，Scheme语言中还有很多，诸如：eval，delay，for-each，force，call-with-current-continuation等过程绑定的操作定义，它们都无一例外的提供了相当灵活的数据处理能力，也就是另初学者望而生畏的算法，当你仔细的体会了运算过程中用到的简直妙不可言的算法后，你就会发现Scheme语言设计者的思想是多么伟大。

回页首

四．输入输出

Scheme语言中也提供了相应的输入输出功能，是在C基础上的一种封装。

端口

Scheme语言中输入输出中用到了端口的概念，相当于C中的文件指针，也就是Linux中的设备文件，请看下面的操作：

guile> (current-input-port)
#<input: standard input /dev/pts/0> ;当前的输入端口
guile> (current-output-port)
#<output: standard output /dev/pts/0> ;当前的输出端口

判断是否为输入输出端口，可以用下面两个过程：input-port? 和output-port? ，其中input-port?用来判断是否为输入端口，output-port?用来判断是否为输出端口。

open-input-file，open-output-file，close-input-port，close-output-port这四个过程用来打开和关闭输入输出文件，其中打开文件的参数是文件名字符串，关闭文件的参数是打开的端口。

输入

打开一个输入文件后，返回的是输入端口，可以用read过程来输入文件的内容：

guile> (define port (open-input-file "readme"))
guile> port
#<input: readme 4>
guile> (read port)
GUILE语言

上面的操作打开了readme文件，并读出了它的第一行内容。此外还可以直接用read过程来接收键盘输入，如下面的操作：

guile> (read)  ; 执行后即等待键盘输入
12345
12345
guile> (define x (read))  ; 等待键盘输入并赋值给x
12345
guile> x
12345

以上为用read来读取键入的数字，还可以输入字符串等其它类型数据：

guile> (define name (read))
tomson
guile> name
tomson
guile> (string? name)
#f
guile> (symbol? name)
#t

此时输入的tomson是一个符号类型，因为字符串是用引号引起来的，所以出现上面的情况。下面因为用引号了，所以(string? str)返回值为#t 。

guile> (define str (read))
"Johnson"
guile> str
"Johnson"
guile> (string? str)
#t

还可以用load过程来直接调用Scheme语言源文件并执行它，格式为：(load "filename")，还有read-char过程来读单个字符等等。

输出

常用的输出过程是display，还有write，它的格式是：(write 对象端口)，这里的对象是指字符串等常量或变量，端口是指输出端口或打开的文件。下面的操作过程演示了向输出文件temp中写入字符串"helloworld"，并分行的实现。

[root@toymouse test]# guile
guile> (define port1 (open-output-file "temp"))  ; 打开文件端口赋于port1
guile> port1
#<output: temp 3> 
guile> (output-port? port1)
#t                     ; 此时证明port1为输出端口
guile> (write "hello\\nworld" port1)
guile> (close-output-port port1)
guile> (exit)               ; 写入数据并关闭退出
[root@toymouse test]# more temp          显示文件的内容，达到测试目的
"hello
world"

在输入输出操作方面，还有很多相关操作，读者可以参考R5RS的文档。

回页首

五．语法扩展

Scheme语言可以自己定义象cond，let等功能一样的宏关键字。标准的Scheme语言定义中用define-syntax和syntax-rules来定义，它的格式如下：

  (define-syntax 宏名
   (syntax-rules()
    ((模板) 操作))
    . . . ))

下面定义的宏start的功能和begin相同，可以用它来开始多个块的组合：

(define-syntax start
        (syntax-rules ()
                ((start exp1)
                        exp1)
                ((start exp1 exp2 ...)
                        (let ((temp exp1)) (start exp2 ...))) ))

这是一个比较简单的宏定义，但对理解宏定义来说是比较重要的，理解了他你才会进一步应用宏定义。在规则 ((start exp1) exp1) 中，(start exp1) 是一个参数时的模板，exp1是如何处理，也就是原样搬出，不做处理。这样 (start form1) 和 (form1) 的功能就相同了。

在规则 ((start exp1 exp2 ...) (let ((temp exp1)) (start exp2 ...))) 中，(start exp1 exp2 …) 是多个参数时的模板，首先用let来绑定局部变量temp为exp1，然后用递归实现处理多个参数，注意这里说的是宏定义中的递归，并不是过程调用中的递归。另外在宏定义中可以用省略号（三个点）来代表多个参数。

在Scheme的规范当中，将表达式分为原始表达式和有源表达式，Scheme语言的标准定义中只有原始的if分支结构，其它均为有源型，即是用后来的宏定义成的，由此可见宏定义的重要性。附上面的定义在GUILE中实现的代码。

回页首

六. 其它功能

1. 模块扩展

在R5RS中并未对如何编写模块进行说明，在诸多的Scheme语言的实现当中，几乎无一例外的实现了模块的加载功能。所谓模块，实际就是一些变量、宏定义和已命名的过程的集合，多数情况下它都绑定在一个Scheme语言的符号下（也就是名称）。在Guile中提供了基础的ice-9模块，其中包括POSIX系统调用和网络操作、正则表达式、线程支持等等众多功能，此外还有著名的SFRI模块。引用模块用use-modules过程，它后面的参数指定了模块名和我们要调用的功能名，如：(use-modules (ice-9 popen))，如此后，就可以应用popen这一系统调用了。如果你想要定义自己的模块，最好看看ice-9目录中的那些tcm文件，它们是最原始的定义。

另外Guile在面向对象编程方面，开发了GOOPS（Guile Object-Oriented Programming System），对于喜欢OO朋友可以研究一下它，从中可能会有新的发现。

2. 如何输出漂亮的代码

如何编写输出漂亮的Scheme语言代码应该是初学者的第一个问题，这在Guile中可以用ice-9扩展包中提供的pretty-print过程来实现，看下面的操作：

guile> (use-modules (ice-9 pretty-print))    ; 引用漂亮输出模块
guile> (pretty-print '(define fix (lambda (n)
        (cond ((= n 0) 'iszero)
                ((< n 0) 'lower)
                (else 'upper)))))   ; 此处是我们输入的不规则代码
(define fix
  (lambda (n)
    (cond ((= n 0) 'iszero)
          ((< n 0) 'lower)
          (else 'upper))))     ; 输出的规则代码

3. 命令行参数的实现

在把Scheme用做shell语言时，经常用到命令行参数的处理，下面是关于命令行参数的一种处理方法：

#! /usr/local/bin/guile -s
!#
(define cmm (command-line))
(display "应用程序名称：")
(display (car cmm))  
(newline)
(define args (cdr cmm))
(define long (length args))
(define loop (lambda (count len obj)
 (if (<= count len)
  (begin
   (display "参数 ")
   (display count)
   (display " 是：")
   (display (list-ref obj (- count 1)))
   (newline)
   (set! count (+ count 1))
   (loop count len obj)))))
(loop 1 long args)

下面是运行后的输出结果：

[root@toymouse doc]# ./tz.scm abc 123 ghi
应用程序名称：./tz.scm
参数 1 是：abc
参数 2 是：123
参数 3 是：ghi

其中最主要的是用到了command-line过程，它的返回结果是命令参数的列表，列表的第一个成员是程序名称，其后为我们要的参数，定义loop递归调用形成读参数的循环，显示出参数值，达到我们要的结果。

4. 特殊之处

一些精确的自己计算自己的符号

数字 Numbers  2 ==> 2
字符串 Strings  "hello" ==> "hello"
字符 Charactors #\\g ==> #\\g
辑值    Booleans #t ==> #t
量表 Vectors  #(a 2 5/2) ==> #(a 2 5/2)

通过变量计算来求值的符号

如：

 
 
 x ==> 9
    -list ==> ("tom" "bob" "jim")
 factoral ==> #<procedure: factoral>
   ==> #<primitive: +>

define 特殊的form

(define x 9) ，define不是一个过程，它是一个不用求所有参数值的特殊的form，它的操作步骤是，初始化空间，绑定符号x到此空间，然后初始此变量。

必须记住的东西

下面的这些定义、过程和宏等是必须记住的：

define，lambda，let，lets，letrec，quote，set!，if，case，cond，begin，and，or等等，当然还有其它宏，必需学习，还有一些未介绍，可参考有关资料。

走进Scheme语言的世界，你就发现算法和数据结构的妙用随处可见，可以充分的检验你对算法和数据结构的理解。Scheme语言虽然是古老的函数型语言的继续，但是它的里面有很多是在其它语言中学不到的东西，我想这也是为什么用它作为计算机语言教学的首选的原因吧。

不完備定理

2014-01-01T03:31:00.004-08:00

Die Grundzeichen des Systems P sind die folgenden:
I.Konstante: "~"(nicht), "v"(oder), "Π" (fuer alle), "0" (null), "f" (der Nachfolger von), "(", ")", (Klammern).

II.Variable ersten Typs(fuer Individuen, d. h. natuerliche Zahlen inklusive 0)):

下列為P系統之基本符：
I.常符:
~ : 非
v : 或
Π : 對所有
0 : 零
f : 後繼函數，命名源自德文後繼 Nachfolger
( ) :括號

II.第一型變數(對個體，即自然數包含零)

陣列操作

哥德爾數定義

17.Z(n) ≡ nN[R(1)]
Z(n) ist das Zahlzeichen für die Zahl n.
Z(n) 是整數 n 的整數符號表示。

命名源自德文整數 Zahl。

Satz V. Zu Jeder rekursiven Relation R(x1...xn) gibt es ein n-stelliges Relationenszeichen r (mit den freien Variablen) (u1, u2...un), so daß für alle Zahlen-n-tuple (x1, x2,...xn) gilt:

定理V. 對每個遞迴關係 R(x1...xn) 均有一個 n 元關係符號 r(帶有自由變數)(u1,u2...un)，且對所有n元整數序對(x1,x2...xn)滿足下式：

R(x1...xn) => Bew[Sb(r u1 ...un )] (3)
Z(x1)...Z(xn)

~R(x1...xn) => Bew[Neg Sb(r u1 ...un )] (4)
Z(x1)...Z(xn)

monad 函數用法

2013-12-03T17:45:00.000-08:00

forM_

模擬一般程式語言 for 建構子

forM_ xs $ \s -> do
putStrLn "Here's a string:"

forM_ s print

putStrLn "Now it's done."

parsec 剖析器組合子語義

2013-11-27T16:46:00.000-08:00

字元剖析器

a = char 'a'

a 剖析器會消化 a 字元，並傳回字元 a，若為其它字元則會剖析失敗。

序列剖析器

序列剖析器可組合數個剖析器，這些剖析器以do區塊組合，並依序應用這些剖析器分析，若序列中某個剖析器失敗，則整個剖析器便失敗，如下例：

openClose = do{ char '('
              ; char ')'
              }

openClose 會先剖析 ( 字元，若剖析成功，則再剖析 ) 字元。
預測剖析器

預測剖析器依掃描之首字元來選擇子剖析器，子剖析器以 <|> 運算子組合，此掃描首字元會被消化掉。

任何一個子剖析器成功，則傳回該子剖析器之值。

aORb = char 'a'
<|> char 'b'
a
b

aORb 可剖析 a 字元或 b 字元。

try 剖析器

預測剖析器可利用 <|> 運算子來建構。

testOr  =   string "(a)"
        <|> string "(b)"

testOr 剖析器因只依掃描之首字元來選擇剖析器，而上例首字元均為 (，故無法明確選擇用那個剖析器，會出現下列錯誤。

Main> run testOr "(b)"      
parse error at (line 1, column 2):
unexpected 'b'
expecting 'a'

必須用左因子分解法修改剖析器才可，如下：

testOr1 = do{ char '('

            ; char 'a' <|> char 'b'
            ; char ')'
            }

若不想用左因子分解法，則可使用 try 剖析器，try 剖析器若剖析失敗，則會把消化的輸入復原。

testOr2 =   try (string "(a)")
        <|> string "(b)"

testOr3 =   do{ try (string "(a"); char ')'; return "(a)" }
        <|> string "(b)"

空條件剖析指若沒有任何剖析器可選擇，則會在沒有消化任何輸入下，成功傳回值。

parens :: Parser ()

parens = do{

char '(' ;
parens ;
char ')' ;
parens
}
<|> return ()
上述剖析器可剖析以下字串
()
(())

分隔字串處理(sepBy, endBy, sepEndBy)

parsec 提供2個剖析組合子，sepBy 及 endBy，用來處理實體由分隔字串區分之串列，最常見的格式應該是csv(comma seperated values)逗號分隔值組。

這些組合子均接受兩個參數，第一個是剖析實體之組合子，另一個是剖析分隔字串之組合子，最後在無法繼續剖析時，傳回實體值之串列。
簡單的語義如下例：

x endBy _

x_x_x_x_x_ -> [x,x,x,x,x]

x sepBy _

x_x_x_x_x -> [x,x,x,x,x]

x sepEndBy _

x_x_x_x_x_ -> [x,x,x,x,x]
x_x_x_x_x -> [x,x,x,x,x]
xa_ -> [x] a 並非 x 可剖析，故傳回一個 a。

num endBy . 接受下列字串並傳回：
1. -> [1]
1.1. -> [1,1]
1.1.2. -> [1,1,2]

letter sepEndBy ,
"" -> []
a -> [a]
a, -> [a]
a,b -> [a,b]
a,b, -> [a,b]
ab -> [a]

Continuation

2012-06-26T01:25:00.001-07:00

call/cc 語義

(define (f return)
  (return 2)
  3)
 
(display (f (lambda (x) x))) ; displays 3
 
(display (call-with-current-continuation f)) ; displays 2

Calling f with a regular function argument first applies this function to the value 2, then returns 3. However, when f is passed to call/cc (as in the last line of the example), applying the parameter (the continuation) to 2 forces execution of the program to jump to the point where call/cc was called, and causes call/cc to return the value 2. This is then printed by the display function.

这个很难理解，而且几乎找不到解说资料。

1.什么是current-constitution？

The current continuation at any point in the executionof a program is an abstraction of therest of theprogram.

current-constitution就是运行到目前，剩余的程序的抽象。

2.怎么去call？

就是用call/cc这个过程来调用。

call/cc参数必须为一个单参数的过程pro，call/cc 构造一个具体的“目前继续”的代表传递给pro，而“目前继续”由过程kont来表示。每一次kont被传递一个值，它返回该值给call/cc的目前继续，这个值本质上就变为call/cc的值。如果pro没有引用kont，pro的返回值变成call/cc的值。

被翻译成汉语了还是这么难以理解啊！

大概的意思就是：call/cc会以一个单参数的过程(设为pro)为参数，pro的参数(设为kont)会夺取pro的目前继续，那pro没有“目前继续”怎么办？放心，call/cc会为其构造一个（不过当然是山寨货了），而kont有了pro的”目前继续“也变成了一个过程(procedure)。每当kont被传递一个值，它会把她送给call/cc。如果没有传递值给kont，pro会把返回值送给call/cc。

说的再简单点的话：

kont想出人头地，抢了大哥pro的东西”current-constitution“，自己地位提高了，大哥却很伤心，kont虽然觉得对不起大哥，但是地位的诱惑还是很大的，不愿意把东西还给大哥。call/cc看到了，自己造了一个山寨货给pro，kont为感谢call/cc凡是自己收到的东西（地位提高了嘛，自然就有人1414），都送给call/cc，pro为了感谢call/cc，凡是别人送的东西（当然和kont的东西相比不值什么钱）也都送给call/cc。这么看来call/cc真是好奸啊！

例子：

(+ 2

(call/cc

(lambda (kont)

(+ 3 (kont 5))))

kont收到礼物了，所以会返回：

(+ 2 5)

=> 7

(+ 2

(call/cc

(lambda (kont)

(+3 5))))

看来还有人恋旧情，pro收到礼物：

(+ 2 8)

=> 10

用法一：退出循环

定义一个函数list-product，该函数接受一个列表，返回列表中所有元素的积。

法一：

(define list-product

(lambda (s)

(let recur ((s s))

(if (null? s) 1

(* (car s) (recur (cdr s)))))))

这样定义可行，但是如果有一个列表有几百个元素，而第二个元素就是零会怎么样？

结果这个程序会一个劲的傻算，浪费大家时间，还有我的电费。

用call/cc会怎么样呢？

(define list-product

(lambda (s)

(call/cc

(lambda (exit)

(let recur ((s s))

(if (null? s) 1)

(if (= (car s) 0) (exit 0)

(* (car s) (recur (cdr s)))))))))

程序突然变长了不少，这个就是代价吧！我们只用分析很色部分，其余的和上边的那个一样。

红色部分：如果在某一步（程序是从左到右一步一步算）发现出现了0，那个2B kont——现在是exit，就会收到礼物0，他立马返回该值给call/cc，而程序的结果就是call/cc的返回值kont送的0。

用法二：树的匹配

定义一个谓词same-fringe?匹配列表的展开是否相同

如：(same-fringe? '(1 (2 3)) '((1 2) 3))=>#t(same-fringe? '(1 2 3 4) '(1 (3 2) 4 ))=>#f

定义：

(define same-fringe?

(lambda (tree1 tree2)

(let loop ((ftree1 (flatten tree1))

(ftree2 (flatten tree2)))

(cond ((and (null? ftree1) (null? ftree2)) #t)

((or (null? ftree1) (null? ftree2)) #f)

((eqv? (car ftree1) (car ftree2))

(loop (cdr ftree1) (cdr ftree2))

(else #f)))))

其中函数flatten的作用为将tree展开，使之只含最外面一对括号。

例如：(1 (2 3) 4)展开为(1 2 3 4)

faltten的定义：

(define flatten

(lambda (tree)

(cond ((null? tree) '())

((pair? (car tree))

(append (flatten (car tree))

(flatten (cdr tree))))

(else

(cons (car tree)

(flatten (cdr tree)))))))

我们先看一下这个faltten的定义是不是能满足我们的要求。

1.如果要展开的列表为空，返回空表。

2.如果第一个元素是一个pair，我们就把它看作是列表吧，因为列表也是pair。

就是说这种情况：((2 4) 6)，它会把剩余的展开附加到(2 4)的展开，结果就为：(2 4 6).

3.如果第一个元素不为pair，会把第一个元素之外的剩余部分的展开附加到第一个元素后。

这样：(2 (4 5)) => (2 4 5)

flatten确实能达到我们的要求。

再来看same-fringe?

它会先用flatten把两棵树整个展开，然后从左到有依次比较各个元素。

and部分：如果最后两棵树的元素都为空了，那么结果为真。

or部分：如果最后其中一个为空而另一个不为空（不可能两者都为空，因为or字句在and字句后），那么结果为假。

eqv?部分：如果这一步两者相同，就进入下一步循环。

否则(else部分)：就为假。

在这里我们终于说明same-fringe?可以达到我们的目地。

但是肯定是有问题的呀，我们的call/cc还没出马呢，举一些极端情形下的例子，问题就出来了。

假设：两颗树都很长很长，比如几千个元素，而它们的展开第二个元素就不同。那我们就没必要把他们全堵展开。

函數調用與continuation

一般函數調用方法都是使用堆棧，用Activation record或Stack frame來記錄從最頂層函數到當前函數的所有context。

一個frame/record就是函數的局部上下文信息，包括所有局部變量的值和SP, PC指針的值（通過靜態分析，某些局部變量的信息是不必保存的，特殊的如尾調用的情況則不需要任何stack frame。不過，邏輯上，我們認爲所有信息都被保存了）。

函數的調用前往往伴隨著一些push來保存context信息，函數退出時則是取消當前的record/frame，恢複上一個調用者的record/frame。

象pascal這樣的支持嵌套函數的，則需要一個額外的指針來保存父函數的frame地址。不過，無論如何，在任何時候，系統保存的就是一個後入先出的堆棧，一個函數一旦退出，它的frame就被刪除了。

Continuation則是另一種函數調用方式。它不采用堆棧來保存上下文，而是把這些信息保存在continuation record中。這些continuation record和堆棧的activation record的區別在于，它不采用後入先出的線性方式，所有record被組成一棵樹（或者圖），從一個函數調用另一個函數就等于給當前節點生成一個子節點，然後把系統寄存器移動到這個子節點。一個函數的退出等于從當前節點退回到父節點。

這些節點的刪除是由garbage collection來管理。如果沒有引用這個record，則它就是可以被刪除的。

這樣的調用方式和堆棧方式相比的好處在哪裏呢？

最大的好處就是，它可以讓從任意一個節點跳到另一個節點。而不必遵循堆棧方式的一層一層的return方式。比如說，在當前的函數內，只要有一個其它函數的節點信息，完全可以選擇return到那個函數，而不是循規蹈矩地返回到自己的調用者。也可以在一個函數的任何位置儲存自己的上下文信息，然後，在以後某個適當的時刻，從其它的任何一個函數裏面返回到自己現在的位置。

Scheme語言有一個CallCC (call with current continuation)的機制，也就是說：
取得當前的continuation，傳遞給要call的這個函數，這個函數可以選擇在適當的時候直接return到當前的continuation。

經典的應用有：exception，back-tracking算法, coroutine等。

應用continuation對付exception是很明顯的，只要給可能抛出異常的函數一個外面try的地方的continuation record，這個函數就可以在需要的時候直接返回到try語句的地方。

　　Exception-handling也可以利用continuation。c++等語言普遍采用的是遇到exception就直接中止當前函數的策略，但是，還有一種策略是允許resume，也就是說，出現了異常之後，有可能異常處理模塊修複了錯誤發生的地方然後選擇恢複執行被異常中斷了的代碼。被異常中斷的代碼可以取得當前的continuation，傳遞給異常處理模塊，這樣當resume的時候可以直接跳到出現異常的地方。

　　Back-tracking算法也可以用類似的方法，在某些地方保存當前的continuation，然後以後就可以從其它的函數跳回當前的語句。

　　Coroutine是一個並行計算的模型。它讓兩個進程可以交替執行。典型的coroutine的應用例子如consumer-producer。比如說：

　　Code:Producer ( c ):

　　Loop:

　　Produce;

　　CallCC c

　　Consumer( p ):

　　Loop:

　　Consume;

　　Callcc p

　　這兩個線程接受對方的continuation，在需要交出控制的時候，就把自己的continuation傳遞給對方。如此，兩者就可以交替執行，而不需要返回。

　　Continuation機制的優化始終不是一個trivial的問題，實際上采取continuation的語言不多。而且，continuation調用方式依賴垃圾收集，也不是c/c++這類中低級的語言所願意采用的。

　　不過，continuation的思想仍然是有其用武之地的。有一種設計的風格叫做continuation-passing-style。它的基本思想是：當需要返回某些數據的時候，不是直接把它當作函數的返回值，而是接受一個叫做continuation的參數，這個參數就是一個call-back函數, 它接受這個數據，並做需要做的事情。

　　舉個例子：

　　Code:X = f();

　　Print x;

　　把它變成continuation-passing-style, 則是：

　　f(print)；

　　F()函數不再返回x, 而是接受一個函數，然後把本來要返回的x傳遞給這個函數。

　　這個例子也許看上去有點莫名其妙：爲什麽這麽做呢？對Haskell這樣的語言，一個原因是：

　　當函數根據不同的輸入可能返回不同類型的值時，用返回值的話就必須設計一個額外的數據結構來處理這種不同的可能性。比如：

一個函數f(int)的返回值可能是一個int, 兩個float或者三個complex，那麽，我們可以這樣設計我們的函數f.

　　Code:F:: Int - (Int-a) - (Float-Float-a) - (Complex-Complex-Complex-a) - a

這個函數接受一個整形參數，三個continuation回調用來處理三種不同的返回情況，最後返回這三個回調所返回的類型。

另一個原因：對模擬imperative風格的monad，可以在函數中間迅速返回（類似于C裏面的return或者throw)

對于C++，我想，除了處理不同返回類型的問題，另一個應用可以是避免返回值的不必要拷貝。雖然c++現在有NRV優化，但是這個優化本身就很含混，各個編譯器對NRV的實現也不同。C++中的拷貝構造很多時候是具有副作用的，作爲程序員，不知道自己寫的的副作用到底是否被執行了，被執行了幾次，總不是一個舒服事。

而continuation-passing-style，不依賴于任何偏僻的語言特性，也不會引入任何的模棱兩可，也許可以作爲一個設計時的選擇。舉個例子, 對于字符串的拼接，如果使用continuation-passing-style如下：

　　Code:Template<class F

　　Void concat(const string& s1, const string& s2, F ret){

　　String s(s1);

　　S.append(s2);

　　ret(s);//此處，本來應該是return(s)，但是我們把它變成ret(s)。

　　}

　　我們就可以很安心地說，我們此處沒有引入任何不必要的拷貝，不論什麽編譯器。

當然，continuation style的問題是，它不如直接返回值直觀，類型系統也無法保證你確實調用了ret(s)。而且，它需要一個function object，c++又不支持lamda，定義很多trivial的functor也會讓程序變得很難看。

　　利弊如何，還要自己權衡。

Scheme 是一門神奇的編程語言，它不僅是世界上第一個完整支持閉包（closure）的語言，也是世界上第一個提供continuation 的語言。你可以看到wiki 上幾個關於Continuation 的條目全部用Scheme 作為示例語言。如無特指，本文以及接下來的兩篇文章中凡是提到continuation 的地方，均是指Scheme 中的continuation。

During the evaluation of a Scheme expression, the implementation must keep track of two things: (1) what to evaluate and (2) what to do with the value. ... We call "what to do with the value" the continuation of a computation.

Continuation 就是一個表達式被求值之後，接下來要做的事情。描述很簡單，但是Scheme continuation 的用法比較奇葩，導致我在學習continuation 的過程中被幾個問題困擾了很久，不過沒關係，哥現在終於搞清楚了。寫下這篇文章不是為了說明continuation 是什麼，而是想能幫助其他人更好地理解這個東西。下面我們通過幾個小實驗全面了解continuation 的各個特性，在看每一個例子的時候，希望你先思考一下“這段代碼的結果是什麼？”、或者“為什麼是這個結果？”，然後再看我的解說。

I. 非本地退出 Non-local exit

非本地退出是初學continuation 很好的例子，因為它邏輯簡單，並且體現了continuation 的三個特性，：

continuation as first-class，簡單地說就是continuation 也可以視為一等公民，可以當做參數被傳遞和返回；

continuation is represented by procedure，也就是說可以視continuation 為過程，可以調用它，本來也應該如此，因為continuation 表示的正是“將來要做的事情；

假設call/cc 捕捉了當前的continuation，並綁定到lambda 的參數cc，那麼在lambda 函數體內，一旦cc 被直接或間接的作為過程調用，那麼call/cc 會立即返回，並且提供給cc 的參數即為call/cc 的返回值。

請看下面這段程序：

(define (test element cc)
  (if (zero? element)
      (cc 'found-zero) ; non-local exit
      (void))) 


(define (search-zero test lst) 
  (call/cc 
   (lambda (return) 
     (for-each (lambda (element)
                 (test element return)
                 (printf "~a~%" element)) ; print
               lst)
     #f)))


(search-zero test '(-3 -2 -1 0 1 2 3))

運行結果：
-3
-2
-1
'found-zero

函數search-zero 遍歷表中所有的元素，每一次都把當前的continuation 取出來然後傳給test，一旦遇到0，就立即終止並返回'found-zero。本來for-each 應當遍歷了整個表，但是test發現0的時候，就把'found-zero 傳給cc，並調用之，由此search-zero 在這時直接返回，而不會執行下剩下的迭代。

我把函數的一次次求值畫成一段段的箭頭，當test 遇到0的時候，它利用cc 執行了一次非本地退出，跳到了cc 定義的continuation，怎麼知道這個continuation 是什麼呢？分析一下它的值被用來做什麼了。由於search-zero 的整個函數體都被call/cc 包起來了，所以call/cc 的返回值剛好就是search-zero的返回值，而這個值接下來被用來執行的操作就是輸出到屏幕——這就是cc 的內容，test 利用cc 令search-zero 中的call/cc 返回'found-zero，隨後這個結果被輸出到了屏幕上。

實際上還沒完，R5RS描述道，“ The continuation represents an entire (default) future for the computation”。 continuation 不僅保存了這個表達式的值被求出來後拿去做了什麼，還保存著這個值被求出來後，對後序表達式的求值操作。 search-zero 是在頂層被調用的，所以cc 還包括“提示下一個輸入，執行輸入的表達式，如此永不停歇”。也就是說， cc 中包含著一個無限的操作—— 一時難以理解是吧，但事實就是如此，哈哈哈。

再看一個生成器，它接收一個列表作為參數，每次被調用的時候就返回一個元素，有點像python 的yield：


(define (generate-one-element-at-a-time lst)
  ;; Hand the next item from a-list to "return" or an end-of-list marker
  (define (control-state return)
    (for-each 
     (lambda (element)
       (call/cc
        (lambda (resume-here)
          ;; Grab the current continuation
          (set! control-state resume-here) ;; !!!
          (return element))))
     lst)
    (return 'end))

  (define (generator)
    (call/cc control-state)) 

  ;; Return the generator 
  generator)

(define generate-digit
  (generate-one-element-at-a-time '(0 1 2)))

> (generate-digit)
0
> (generate-digit)
1
> (generate-digit)
2
> (generate-digit)
'end
> (generate-digit)
'end

又是一个非本地退出的例子，值得注意的是 control-state，这个函数第一次被调用的时候它还是个函数，但是看注释“!!!”的这一行，经过第一次调用后， control-state 就把自己改成了一个 continuation，随后借助 generator 传进来的 return，完成一次非本地退出（在 control-state 里退出generator）。第一次看这个可能有点晕，因为这里有两个 call/cc，而且还是嵌套的。这两个 call/cc 各司其职，generator 里的 call/cc 是为了非本地退出，第二个 call/cc 则是为了记录遍历列表的状态——这样下一次调用 generator 的时候，通过 control-state（它是个 continuation），就能直接从上次修改 continuation 的地方继续运行，从而跳了回去，达到生成器的效果。

通过在 call/cc 内 apply continuation，我们可以在任意时刻从函数中跳出来；通过修改中途获取的 continuation，我们还可以跳回去。

II. 非引用透明性

我们知道，引用透明性（Referential Transparent）是纯函数式语言的重要特征，但通过 call/cc，我们能定义出一个不具有引用透明性的函数：

(define (get-cc) (call/cc (lambda (c) c)))

看出 get-cc 做了什么吗？它捕捉到当前的 continuation 然后返回，显然这个函数的返回值受到上下文——准确地说是下文，的影响，所以它其实很不透明= = 但正是它的不透明性能帮助我们更好地了解 continuation。来看下面这段代码：


> (define x (get-cc))
> x
#< continuation>
> (x 10)
> x
10
> (number? x)
#t
> ((get-cc) 10)
. . a application: not a procedure;
 expected a procedure that can be applied to arguments
  given: 10
  arguments...:
   10

你明白上面发生了什么吗？ x 明明是个 continuation，怎么变成10了？？为什么 (get-cc) define 成 x可以被调用，却不能被直接调用？？？

我曾经被这几个“奇怪的现象”困扰了好一阵子。但是想清楚 get-cc 的不透明性及其缘由就明白了。实际上，经过 define 之后， x 获得了一个 continuation，这个 continuation 是什么呢？……是获取一个值，然后绑定到 x —— 恰好就是 define 所做的事情。所以再以10为参数调用 x 的时候， continuation 把10绑定到 x，x 又被绑定了一次，就变成数字10了。但是直接对 (get-cc) apply 10的时候，却提示错误，这是因为这个 (get-cc) 接下来被用来当成函数调用了，所以给它传一个10之后，这个10就被当做函数执行，显然这是不对的。get-cc 是个神奇的函数，就是获取它这个位置上的 continuation， (get-cc) 自己被用来做了什么事，它返回的 continuation 就对别人做同样的事，以彼之道，还施彼身。如果你感到有点晕，别急着往下看，先消化一下。

接下来这个表达式，你能看出它的返回值是什么吗？(let ([x (get-cc)]) (x (lambda (unused) "我擦")))

也许你能马上猜到结果，但是不一定能马上明白。我们仍然从 (get-cc) 开始分析。我们看到 (get-cc)被用来绑定到 x上，随后以 (lambda (unused) "我擦")) 为参数调用 x。现在开始还施彼身。于是，接下来(lambda (unused) "我擦")) 也被绑定到 x 上，然后用参数 (lambda (unused) "我擦")) 调用新的 x，显然这个参数没有用上，所以 x 直接返回了“我擦”。真是我擦啊……

这是最后一个关于 get-cc 的例子。

(((get-cc) (lambda (x) x)) "我又擦")

你应该马上就能猜到，这个表达式返回了“我又擦”，but why?

沿用刚才的思路，先分析 (get-cc) 自己被用来做了什么？它被当成函数，以 (lambda (x) x) 为参数进行调用，调用的返回值又被当成函数，以“我又擦”为参数执行调用。好，(get-cc) 的参数是 (lambda (x) x)——一个恒等函数，于是 (lambda (x) x) 被当成了函数，以 (lambda (x) x)（没错，就是它自己）为参数执行调用，返回值当然还是它自己，又一个恒等函数；最后，这个恒等函数接收参数“我又擦”，当然也就返回“我又擦”。

(get-cc) 的非引用透明性来源于它的语义，它总是捕捉当前的 continuation 并返回之。可以这么理解call/cc，它可以出现在任何一个本应是表达式的地方（它占了表达式的位置）。凡是表达式都要求值，并且还要求它的后续表达式的值，程序员通过call/cc，可以在该表达式出现的地方捕捉（catch）到该表达式的后续操作。被捕捉到的后续操作即为 continuation，某种程度上说，它就像个时光机，调用捕捉到的 continuation 可以回到过去。但是注意调用 continuation 和非本地退出的区别，后者是在 call/cc 的函数体内（直接或间接）调用捕捉到的 cc，这是 continuation 的特殊用法，它能立即退出，而且可以在非本地退出；而前者是在相应 continuation 的 call/cc 之外调用，它的作用就是重复后续操作。

III. 移花接木
这一部分只讲解一个例子，不过这个例子更绕~ V神跟我说，monad 就是给一个函数打很多个孔，然后灵活地组合，我觉得 continuation 也是给函数打孔，而且不同函数打的孔还可以对接起来。

生产者-消费者问题是检验多任务机制的经典问题，我们可以用 continuation 模拟这个过程，即生成-消费-再生产-再消费-... (define dish #f) (define (put! fruit) (set! dish fruit)) (define (get!) (let ([fruit dish]) (set! dish #f) fruit)) (define (consumer do-other-stuff) (let loop () (when dish (printf "C: get a ~a~%" (get!)) (set! do-other-stuff (call/cc do-other-stuff)) (loop)))) (define (producer do-other-stuff) (for-each (lambda (fruit) (put! fruit) (printf "P: put a ~a~%" fruit) (set! do-other-stuff (call/cc do-other-stuff))) '("apple" "strawberry" "peach" "grape"))) (producer consumer)

producer 通过 for-each “生产”了几个水果，每生成一个就放进盘子里，并通过 call/cc 把控制权交给 consumer，consumer 先看看盘子里有没有水果，如果有就取。运行结果不难预科： > (producer consumer) P: put a apple C: get a apple P: put a strawberry C: get a strawberry P: put a peach C: get a peach P: put a grape C: get a grape

实际上这段程序有两个过程交替运行，我们知道多任务控制流的一个关键就是，保存每个任务的上下文，让它切出去再返回的时候能接着执行，就像没有发生过切换一样。这个任务，continuation 完全胜任。How does it works?

producer 往盘子里放水果之后，通过 call/cc 调用 consumer，它的 continuation 就传进 consumer了（consumer 的 do-other-stuff 就是 producer 的 continuation）， consumer 取出水果之后，就能通过这个 continuation 回到 producer，同时它也把自己的 continuation 传给了 producer。两个函数通过互传 continuation 的方式实现切换和恢复。

IV. 模拟多任务

最后，我们看看如何用 continuation 模拟多任务。刚才的例子已经模拟了一个很简单的多任务过程，即producer 和 conmuser 两个过程“同时”运行，但那是两个任务都知道对方的存在从而实现精确的同步。如果是几个独立的进程，如何并发执行呢？ (define lwp-list '()) (define lwp (lambda (thunk) (set! lwp-list (append lwp-list (list thunk))))) (define start (lambda () (let ([p (car lwp-list)]) (set! lwp-list (cdr lwp-list)) (p)))) (define pause (lambda () (call/cc (lambda (k) (lwp (lambda () (k #f))) (start))))) (lwp (lambda () (let f () (pause) (display "h") (f)))) (lwp (lambda () (let f () (pause) (display "e") (f)))) (lwp (lambda () (let f () (pause) (display "y") (f)))) (lwp (lambda () (let f () (pause) (display "!") (f)))) (lwp (lambda () (let f () (pause) (newline) (f))))

lwp 即 ligth-weight process, lwp-list 是进程表，不难看出 lwp 和 start 的作用分别是添加一进程到进程表、和从进程表里取出一个进程并执行，理解这段程序的关键在于 pause。

pause 是这些进程真正的调度者，它不仅有副作用，而且也不具有引用透明性，所以难以理解，我们分析一下。(lwp (lambda () (k #f))) 把 pause 的 continuation 添加到进程表尾，以备将来恢复。但注意，call/cc 能取出一个函数的全部未来，当然也包括这个函数执行完毕后的后续操作——每一个 lwp 调用pause 之后的操作是“输出一个字符，然后再递归调用自己”，这些操作当然也在 pause 的 continuation 里面——

你看出来了吗？这些进程第一次被执行时不输出任何信息，因为它们到达 (pause) 的时候，pause 把剩余操作打包成 continuation 放到进程表尾，然后就执行下一个进程了。最后的执行结果就是不停的打印 "hey!"： > (start) hey! hey! hey! hey! hey!

V. 总结一下

如果充分理解的上面所有的例子，那也就相当程度地掌握了 continuation。说了那么多，continuation 有什么用呢？这篇文章举的例子已展示了一些使用 continuation 的模式，如非本地退出、保存上下文等。在第三篇文章中我们还会看到如何用 continuation 消除非尾递归。continuation 为程序员提供了一种强大、灵活、近乎随心所欲的控制流（Tom 言：时光机），但是它太锋利，而且很多时候还要涉及一些带副作用的操作，另外想必你也发现带 call/cc 的代码非常难读= =，综上所述，除非你已经非常非常熟悉 continuation，否则不建议轻易使用。其实我仍然有一些小细节没有讲，有些是连自己也没明白透，有些是特意留着让你自己去发现。

下一篇文章，我们将领略 continuation 的终极奥义，真·阴阳谜题，敬请期待。

Unicode與Big5轉換

2012-06-03T19:15:00.000-07:00

Unicode
大五碼 ( BIG5 )，是用一個數字來表示英文字母及一些符號的數碼。對歐美國家的文字來說，只需約一～兩百個就已足夠，這是因為他們的文字都是以字母拼成，而每種語言的字母個數不多，例如英文字母僅 26 個，再加上空白、標點符號、阿拉伯數字等等，不超過一百個。
一個位元組 ( byte ) 有 8 個位元，可以表示 0～255 之間的數值，也就是說可以表示 256 種 ( 28=256 ) 不同的數字，若一個數表示一個字母或符號，那麼 ASCII 碼用一個位元組的長度就已經夠了，後來 ASCII 果真以 7 個位元表示，而 IBM 推出 PC/XT 時，把 ASCII 擴充為 8 個位元寬，即為一個位元組的大小。像 ASCII 這種系統，我們稱之為『單位元組編碼系統』( SBCS，Single Byte Code System。也有人稱為『單位元組字集』，Single Byte Character Set )。
但對於中文，就嫌不夠了。常用的中文字保守估計也有數千個，因此得用兩個位元組來表示文字，2 個位元組共有 16 個位元，最多可以表示 216，亦即 65536 個數，像這種以 2 個位元組編碼的方式稱為『雙位元組編碼系統』( DBCS，Double Byte Code System，也有人稱為『雙位元組字集』，Double Byte Character Set )。早期中文電腦發展時，並沒有強而有力的國家標準編碼，所以造成每一家公司或機構所發展的編碼不同而不相容。到了中華民國 73 年，中華民國財團法人資訊工業策進會和五間電腦公司，宏碁、神通、佳佳、零壹及大眾，所共同發展一套中文的編碼系統，這五家電腦公司在當時是數一數二的大公司，其影響力可謂舉足輕重，而他們所發展的編碼系統就稱為大五碼 ( Big5 )。詳情見維基百科有關 Big5 的說明。
由於大五碼的誕生，使得中文編碼有依循的標準，後來在 DOS 系統中的倚天中文，Windows 3.1 以及 Windows 95/98/Me 都採用這先後採用這套編碼來處理正體中文。但是 Big5 碼所收錄的字太少，許多人名、地名並沒有包括在內。因此後來有許多機構在 Big5 的基礎上加以擴充。現今 ( 民國 80～95 年 )，使用正體中文的國家或地區，像中華民國、香港、新加坡以及海外華人的中文電腦，大多使用 Big5 碼。

倚天中文系統在 DOS 系統下執行的倚天中文，採用的就是 Big5 碼。倚天中文系統執行後，會常駐於記憶體裏。倚天中文顯示文字的原理與英文類似，請參考第三十章顯示記憶體的說明。倚天中文也是把 B800:0000 開始的記憶體當成顯示記憶體，偶數位址是存放 Big5 碼，奇數位址是存放顏色，例如假設在螢幕上左上角顯示綠色的『我學 ASSEMBLY。』這句話，那麼用 DEBUG.EXE 觀察位址 B800:0000，您會看見：
B800:0000 A7 02 DA 02 BE 02 C7 02 20 02 41 02 53 02 53 02 ........ .A.S.S. B800:0010 45 02 4D 02 42 02 4C 02 59 02 A1 02 43 02 20 00 E.M.B.L.Y...C. .
的記憶體內容，其中以白色標起來的 A7DA、BEC7 和 A143 分別是『我』、『學』和『。』的 Big5 碼，而位址 B800:0001、B800:0003、B800:0005、B800:0007 等內容為 02 的位元組是綠字黑底的顏色號碼 ( 參考附錄七的表一 )。或許您會問，如果改變 B800:0001 或 B800:0003 的內容，使它們不一樣，這樣是不是會變成同一個字，但左半部和右半部顏色不同？的確如此，您可以試試看。底下以列表方式說明：

當倚天中文常駐於記憶體後，如果它發現螢幕上的資料屬於 Big5 碼，倚天中文會以這個 Big5 碼查出字形檔中該字的字形，最後再依據字形把字顯示於螢光幕上，這一點與 ASCII 的碼是一樣的。
在倚天中文採用 Big-Endian 的方式存入記憶體。此外在 Big5 的純文字檔案裏，也是以 Big-Endian 方式存入磁碟，這點和 PC 的習慣不同。有關什麼是 Big-Endian？什麼是 Little-Enddian？請參閱後面的說明。
在這種以 Big5 編碼系統中，如果遇到中英文混合資料時，有兩種選擇，一是像上面的例子，ASCII 與 Big5 混合使用，但這樣一個字元可能佔用一個位元組也可能兩個位元組，在計算字串長度時有點困難；另一種是完全採用 Big5 碼，遇到英文時也採用全形字體。
Big5 碼的編碼方式是以筆畫順序為依據，若筆畫相同則依其部首的筆畫排序。您可以到 Openi18n 台灣網頁去查詢每個 Big5 碼所代表的中文字。

萬國碼 ( UNICODE )
緣起隨著網際網路的發達，電腦已不是一座座的孤島，常常需要藉由網路與外界相連，讀取國外的資料，而這些資料不一定是本國語言或英文，像是日文、泰文、阿拉伯文、俄文……等等。甚至有時希望能在同一份文件中，能包含數種文字。要達到這目標，就不能靠一種語文一種編碼的方式了。
為了解決這個難題，自民國 73 年開始，有兩個組織著手研究這個問題。其中一個是國際標準組織 ( ISO，International Organization for Standardization ) 與聯合國下屬的國際電氣技術委員會 ( IEC，International Electro-technical Commission ) 合組的工作小組，該小組草擬提出的 ISO 10646 標準草案。另一個組織是由 IBM、DEC、Sun、Xerox、Apple、MicroSoft、Novell 公司，共同出資成立的 Unicode 協會，該協會設立非營利的 Unicode 公司，並由該公司設計出適用全球的萬國碼 ( Universal Code；簡稱 Unicode，亦有人稱統一碼、單一碼或萬國碼 )。雖然一開始，這兩個組織的工作是各自發展的，但是最後他們體認到世界不需要有兩套編碼，否則豈不是陷於當初的困境？於是在民國 80 年左右，他們合併了雙方的成果變成 ISO 10646/Unicode 標準，提供全世界語言文字與符號的顯示、儲存、傳送等，不但避免了資源的浪費，也能落實統一全球文字交換標準的理想。
要把全球所有文字編碼，不是一件簡單的事情。據估計全世界約有不到七千種語言，但是有些語言只有聲音沒有文字，扣除這些語言，只算有文字的語言約有兩千多種。要把這些語言的每個字都編成碼也不是簡單的工作，因為到底有多少個文字或字母，誰也說不準。但編碼工作總是要繼續的，經過數十年的努力，辛勤的工作總算有的結果，在民國 82 年發表的 ISO 10646。

UCS-4在 ISO 10646 裏用四個位元組來編碼，因此稱為 UCS-4，UCS 是 Universal Multiple-Octet Coded Character Set 的縮寫，意義為多個八位元編碼的廣用文字集，4 代表 4 個位元組。ISO 10646 依位元組高低次序把每一位元組稱為群組 ( group )、字面 ( plane )、列 ( row )、格 ( cell )。群組的最高位元不使用，僅剩七個位元，由 00H～07FH 共 128 個，可分成 128 群組；次高位元組代表字面，所以每一群都有 256 個字面 ( 00～0FFH )，每個字面本應有 216，即 65536 個空間可容納文字 ( 每個文字得佔用一個空間，或稱一個碼位 )，但 ISO 10646 裏規定最後兩格不用，所以每個字面變成 65534 個字。依據這個規則，最多可以把 65534×128×256 ＝2,147,418,112，約二十一億個文字編成碼。有關群組、字面的說明，請參考下圖所示 ( 下圖參考 CNS11643 中文全字庫繪製而成 )：

UCS-2 與 BMP雖然 ISO 10646 裏用四個位元組來編碼，但是實際上，全球重要的語言已經有九成五以上都包含在第 00 群組的第 00 字面。所以為了考慮效率，在 ISO 10646 也特別規定第 00 群組的第 00 字面稱為『基本多語文字面』( Basic Multilingual Plane，簡稱 BMP )，如果所使用的文字都在 BMP 內，那麼就可以用兩個位元組來表示，以節省空間增進效率，像這種字集稱為 UCS-2，也因為效率，世界各國莫不想讓本國文字擠進 BMP 裏。說了這麼多，小木偶整理一下：在實際使用上，萬國碼可分為 UCS-2 與 UCS-4 兩種編碼方式，如果所使用的文字都在 BMP 上，那麼使用 UCS-2 就可以了，否則就必須使用 UCS-4。同一份文件或檔案裏只能選擇其中一種，不是 UCS-2 就是 UCS-4，不能混用，以免造成一個字不定長度的缺點。

世界最重要的幾種語言，如北京話 ( 約八億六千萬人使用 )、英語 ( 約四億三千萬人使用 )、印地語 ( 印度所使用的語言，約三億兩千萬人使用 ) 等語言都已被編入 BMP 中。各語文所佔編碼範圍可以參考維基百科有關基本多語文字面與曾士熊先生所著 Unicode 與 ISO10646 的描述，而各字的編碼可到 www.unicode.org 檢閱。底下是依熊先生的文章所作的介紹：

0000～007Fh： C0 控制碼與基本拉丁字母區。其中 0000～001Fh 為 C0 控制碼，0020h 為空格 ( space )，0021～007Eh 為 ASCII 圖形字元……事實上，這 128 個字元碼只要把前 8 個位元去掉就是 ASCII 碼。

0080～00A0h：控制碼區。0080～009Fh 為 C1 控制碼，00A0h 為不中斷空格 ( no-break space )
00A1～1FFFh：拼音文字區。收容除基本拉丁字母以外的各種拼音文字字元，包括歐洲各國語言、希臘文、斯拉夫語文、希伯來文、阿拉伯文、亞美尼亞文、印度各地方言、馬來文、泰文、寮文、柬普寨文、滿文、蒙文、藏文、印地安語文等。
2000～2BFFh：符號區。收容各種符號，包括標點符號、上下標、錢幣符號、數字、箭頭、數學符號、工程符號、光學辨識符號、帶圈或帶括符的文數字、表格繪製符號、地理圖示、盲用點字、裝飾圖形等。
2C00～2E7Fh：拼音文字區，包含格拉哥里字母、古埃及文、衣索匹亞語等…
2E80～33FFh：中日韓符號區。收容康熙字典部首、中日韓輔助部首、注音符號、日本假名、韓文音符，中日韓的符號、標點、帶圈或帶括符文數字、月份，以及日本的假名組合、單位、年號、月份、日期、時間等。
3400～4DFFh：中日韓認同表意文字擴充 A 區，總計收容 6582 個中日韓漢字。表義文字是指文字像是一種圖形符號，只代表語素，而不代表音節，例如中、日、韓、越等文字即屬表義文字。與表義文字相對的是拼音文字，如英語即是拼音文字。
4E00～9FFFh：中日韓認同表意文字區，總計收容 20902 個中日韓漢字。可到 www.unicode.org 下載各字的編碼。
A000～A4FFh：彝族文字區，收容中國南方彝族文字和字根。
A500～ABFFh：包含加拿大土著語、聲調修飾字母、八思巴字、爪哇語、越南傣語等。
AC00～D7FFh：韓文拼音組合字區，收容以韓文音符拼成的文字。
D800～DFFFh： S 區，專用於 UTF-16。
E000～F8FFh：專用字區，其內容沒有規定，保留供使用者自行添加 ISO 10646 未收容的字元。
F900～FAFFh：中日韓相容表意文字區，總計收容 302 個中日韓漢字。
FB00～FFFDh：文字表現形式區，收容組合拉丁文字、希伯來文、阿拉伯文、中日韓直式標點、小符號、半形符號、全形符號等。

輔助字面除了基本多語文字面以外的字面都稱為『輔助字面』，輔助字面多存放罕用的文字。當使用輔助字面的文字時，就得用 4 個位元組來表示一個字了。第一輔助字面 ( Supplementary Multilingual Plane，簡稱 SMP )，擺放拼音文字，主要為現時已不再使用的文字及符號。範圍在 00010000～0001FFDh。

第二輔助字面，又稱為表意文字補充字面 ( Supplementary Ideographic Plane，簡稱 SIP )，整個範圍在 00020000～0002FFFDh。擺放「中日韓統一表意文字擴展 B 區」，共 43253 個漢字，以及中日韓相容表意文字增補 ( CJK Compatibility Ideographs Supplement )。這些文字主要康熙字典、漢語大字典為基礎，扣除已編入 BMP 的文字，再加上各國所提字集，進行整理。其他字面有些是尚未編入文字，有些對我們而言是幾乎不會用到，所以就不介紹了。不過您應當可以參考上面的 UCS-4 全部編碼空間知道尚有許多空間尚未編碼。

UNICODE 轉換成 BIG5在這一章的例子裏，小木偶打算製作一個程式，使其能把 Unicode 轉換成 Big5 碼。還記得 FAT32 裏的 FDB 中，長檔名格式的檔名是以 Unicode 記錄嗎？此章小木偶打算延續第三十四章的內容，針對 DFC.EXE 的缺點改進使其能顯示長檔名。在 Win 9x/Me 的『DOS 視窗』裏的中文是以 Big5 碼顯示中文，因此長檔名必須轉換成 Big5 碼才能正確顯示，否則是一堆亂碼。

轉換表格︰cp950-u2b.txt要撰寫一個可以把 Unicode 轉換成 Big5 的程式，最大的困難在於製作一張上萬個字的萬國碼轉換成大五碼對照表，幸好在網際網路上已經有人製作好了這張表，在 Mozilla Taiwan：Mozilla 系列與 Big5 中文字碼有這樣的一張表。在眾多 Big5 版本裏，小木偶選擇了微軟的 CP950 版本，原因有兩個，一是為了配合底下的例子，DFC3.EXE，DFC3.EXE 是讀取 Win 9x/Me 系統長檔名，眾所皆知，Win 9x/Me 是微軟的產品，自己所改進的 Big5 碼應該會支援吧？；二是該網頁也建議用這一張表。

在該網頁中下載 cp950-u2b.txt 檔案，它就是把萬國碼轉換成 Big5 的表格。cp950-u2b.txt 是純文字檔，底下是前面幾行的內容︰
# big5 unicode 0x0021 0x00A1 0xA246 0x00A2 0xA247 0x00A3 0xA244 0x00A5 0x007C 0x00A6 0xA1B1 0x00A7 0xA14C 0x00A8 0x0063 0x00A9 0x0061 0x00AA 0x002D 0x00AD 0x0052 0x00AE 0xA1C2 0x00AF ……
由上面可以看出，cp950-u2b.txt 是按照第二列的 Unicode 由小至大排列，而 Unicode 前的十六進位數值就是相對應的 Big5 碼，例如第一行的 Unicode 的 0x00A1 換成 Big5 碼就是 0x0021。因此有了這張表，要把 Unicode 轉換成 Big5 就非常容易了，在此特別感謝這張表格的作者。儘管如此，cp950-u2b.txt 對組合語言的設計者來說，還是有兩點不太方便：

cp950-u2b.txt 所有的資料是按照 C/C++ 的十六進位格式製作的表格，並非按照組合語言十六進位格式記錄。
cp950-u2b.txt 檔案裏共收集了 20192 個中文字，每個中文字必須用 Unicode 及 Big5 碼各記錄一次，這兩種編碼都佔用兩個位元組，所以每個中文字佔用 4 個位元組，因此共用去 80768 個位元組，超過一個區段 64KB 的限制。為了解決這個問題，小木偶先撰寫一程式，U2B_2ASM.ASM，這個程式會製造出一個 CP950-U2B_ASM.INC 檔案，這個檔案是一個組合語言包含檔，他把 cp950-u2b.txt 的資料分成兩個區段，big5 與 ucode，big5 區段只存放 Big5 碼資料而 ucode 區段只存放 Unicode 區段。這兩個區段相同偏移位址的資料是對應的，也就是說 big5:0000 位址是 00021h，而 ucode:0000 則是 000a1h。因此 CP950-U2B_ASM.INC 的內容是像這樣的：
big5 segment dw 00021h,0a246h,0a247h,0a244h,0007ch,0a1b1h,0a14ch,00063h dw 00061h,0002dh,00052h,0a1c2h,0a258h,0a1d3h,00032h,00033h ………… dw 0a155h,0a162h,0a1e3h,0a14eh,0a246h,0a247h,0a1c3h,0a244h big5 ends ucode segment dw 000a1h,000a2h,000a3h,000a5h,000a6h,000a7h,000a8h,000a9h dw 000aah,000adh,000aeh,000afh,000b0h,000b1h,000b2h,000b3h ………… dw 0ff5ch,0ff5dh,0ff5eh,0ff64h,0ffe0h,0ffe1h,0ffe3h,0ffe5h ucode ends
當要把 Unicode 轉換成Big5 碼時，只要找出 Unicode 的偏移位址，再切換成 Big5 碼的區段位址，就可取得相對應的 Big5 碼。例如：
;把 AX 內的 UNICDODE 轉換成 BIG-5 ;輸入：AX－UNICDODE ;輸出：NC：轉換成功，此時 AX=BIG-5 ; CY：轉換失敗，此時 AX=『？』 convert_u2big5 proc near uses bx mov bx,ucode mov gs,bx sub bx,bx ;由 ucode:0000 開始搜尋存於 AX 中的 Unicode 位址 next_code: cmp ax,gs:[bx] je find_out add bx,2 or bx,bx ;如果到 BX=0 ( 搜尋完整個 ucode 區段 ) 都還沒找到， jnz next_code ;，表示沒有相對應的 Big5 碼，轉換失敗 stc ;設定進位旗標 mov ax,35a1h ;Big5 的 0a135h=『？』 jmp short u2b_exit find_out: mov ax,big5 mov gs,ax mov ax,gs:[bx] ;取得 Big5 xchg al,ah ;換成 Big-Endian clc ;清除進位旗標 u2b_exit: ret ;返回主程式 convert_u2big5 endp

Big-Endian 與 Little-Endian第三十三章裏提過，FAT32 分割是利用 VFAT 實現長檔名，不管是中文或英文檔名全都採用萬國碼的方式儲存，而非 Big5 碼。例如，上面例子中有一個檔案名為『費玉清－蘆花州.TXT』在目錄磁區裏的儲存方式如下︰
0000 41 BB 8C 89 73 05 6E 0D-FF 06 86 0F 00 0C B1 82 A;..s.n.......1. 0010 1F 82 4C 6B 5E 8A 2E 00-54 00 00 00 58 00 54 00 ..Lk^...T...X.T. 0020 B6 4F A5 C9 B2 4D 7E 31-54 58 54 20 00 0D 38 77 6O%I2M~1TXT ..8w 0030 68 35 68 35 00 00 AB 1B-4A 33 E1 50 1B 03 00 00 h5h5..+.J3aP....
要注意的是用粉紅色標出來的是萬國碼的『費』字，他的代碼是 8CBBH，而其大五碼是 0B64FH，並非 4FB6H。這一點很奇怪，小木偶也不知為什麼要這樣排。一般在 PC 及其相容機種的資料幾乎以 Little-Endian 的方式排列，但在 FDB 中的 Big5 卻是以 Big-Endian 的方式排列。
所謂 Little-Endian 或 Big-Endian 的排列是指數值存放在記憶體的排列方式。當記憶體位址由低位址開始向高位址排好時，先把較小的位數存入的這種方式稱為 Little-Endian，例如上面的 Unicode 的『費』字，其十六進位為『8CBBH』，『BB』分別是個位、十位數，『8C』分別是千位、百位數，所以『BB』填入較低位址而『8C』填入較高位址。因此在傾印時，常常是低位址先印出來，於是變得顛倒了，但是在記憶體裏的排列卻是正常。有關 Little-Endian 或 Big-Endian 可以參考用 C 語言窺探記憶體。

DFC3.EXE：檢查檔案所佔磁區是否連續DFC3.EXE 用法與 DFC.EXE 相同，它也只能用在 Win 9x/Me 系列，無法在 Windows NT/2k/XP 裏。其執行結果如下圖︰

為了讓 DFC3.EXE 能夠顯示中文長檔名，修改了 DFC.ASM 裏的 get_filename 副程式，使具有長檔名的檔案能夠呼叫 convert_u2big5 副程式，convert_u2big5 副程式的功用就是把 Unicode 碼轉變成 Big5 碼。

組譯方法因為 DFC3.ASM 原始碼幾乎與 DFC.ASM 一樣，且加上一個轉換 cp950-u2b.txt 變成符合組合語言格式及區段的程式，U2B_2ASM.ASM，所以此處不列出整個內容，請下載 AP10.RAR 後解壓縮。

解壓縮後，在 XP 的命令提示字元或 Win 9x/Me 的 MS-DOS 模式中組譯都可成功。組譯時先把 AP10.RAR 裏所有檔案放於同一子目錄，例如 D:\AP10，再把 cp950-u2b.txt 檔案拷貝到這個子目錄，然後切換到此子目錄，並設定 ML.EXE 的路徑，底下是在 Win XP 系統之下以命令提示字元為例子說明：
D:\AP10>dir [Enter] Volume in drive D is FAT32DATA Volume Serial Number is DC74-CCE3 Directory of D:\AP10 2006/11/21 ?? 10:49 6,499 U2B_2ASM.ASM → AP10.RAR 內的檔案 2006/10/22 ?? 05:37 282,703 CP950-U2B.TXT → 自 Mozilla Taiwan 下載 2006/11/17 ?? 09:44 29,551 DFC3.ASM → AP10.RAR 內的檔案 2006/04/05 ?? 04:49 4,881 MYASMINC.INC → AP10.RAR 內的檔案 4 File(s) 323,634 bytes 2 Dir(s) 1,489,784,832 bytes free D:\AP10>path D:\HomePage\MASM611\BIN;%path% [Enter] D:\AP10>ml /AT U2B_2ASM.ASM [Enter] Microsoft (R) Macro Assembler Version 6.11 Copyright (C) Microsoft Corp 1981-1993. All rights reserved. Assembling: U2B_2ASM.ASM Microsoft (R) Segmented Executable Linker Version 5.31.009 Jul 13 1992 Copyright (C) Microsoft Corp 1984-1992. All rights reserved. Object Modules [.obj]: U2B_2ASM.obj/t Run File [U2B_2ASM.com]: "U2B_2ASM.com" List File [nul.map]: NUL Libraries [.lib]: Definitions File [nul.def]:
在組譯時，須下選項『/AT』，這是為了組譯成 U2B_2ASM.COM 檔，而不是 U2B_2ASM.EXE 檔。接下來就可以利用 U2B_2ASM.COM 把 cp950-u2b.txt 轉換成符合組合語言格式及區段的包含檔，CP950-U2B_ASM.INC 了。
D:\AP10>U2B_2ASM [Enter] D:\AP10>dir [Enter] Volume in drive D is FAT32DATA Volume Serial Number is DC74-CCE3 Directory of D:\AP10 2006/11/21 ?? 10:05 <DIR> . 2006/11/21 ?? 10:05 <DIR> .. 2006/11/21 ?? 10:49 6,499 U2B_2ASM.ASM 2006/10/22 ?? 05:37 282,703 CP950-U2B.TXT 2006/11/17 ?? 09:44 29,551 DFC3.ASM 2006/04/05 ?? 04:49 4,881 MYASMINC.INC 2006/11/21 ?? 10:21 775 u2b_2asm.obj 2006/11/21 ?? 10:21 445 U2B_2ASM.COM 2006/11/21 ?? 10:21 368,566 CP950-U2B_ASM.INC 7 File(s) 693,420 bytes 2 Dir(s) 1,489,408,000 bytes free
接下來組譯 DFC3.ASM：
D:\AP10>>ml dfc3.asm [Enter] Microsoft (R) Macro Assembler Version 6.11 Copyright (C) Microsoft Corp 1981-1993. All rights reserved. Assembling: dfc3.asm Microsoft (R) Segmented Executable Linker Version 5.31.009 Jul 13 1992 Copyright (C) Microsoft Corp 1984-1992. All rights reserved. Object Modules [.obj]: dfc3.obj Run File [dfc3.exe]: "dfc3.exe" List File [nul.map]: NUL Libraries [.lib]: Definitions File [nul.def]:
如此就得到 DFC3.EXE，檔案僅 84368 個位元組。不過 DFC3.EXE 只能在 Win 9x/Me 系統中執行，在 Win NT/2k/XP 中無法執行。
註一：在 DOS 系統裏，每個字在螢幕上顯示的寬度都是相同的，但載入倚天中文後，中文字不僅佔用兩個位元組，在螢幕顯示時的寬度也是英文字的兩倍，故稱全形字，而原來的英文自稱為半形字體。不過，在 Big5 碼裏，也有全形字體的英文字母，在 A2CF～A343，同樣的，阿拉伯數字、希臘字母也都有全形字體。
註二：

UTF-16 與 UTF-8UCS-4 字集雖然能容納古今中外全球人類所書寫過的文字及符號，但是其實有九成五以上的文字及符號都編入 UCS-2 字集 ( 即 BMP )。很明顯的 UCS-2 要比 UCS-4 有效率得多，不說別的，單只比較儲存空間，UCS-2 就只有 UCS-4 的一半。設想如果一篇數千字或數萬字的文件裏，就只有十幾個字在 BMP 以外的字面，若只為了這幾個字就得採用 UCS-4 字集，顯然是很不符合經濟效率。因此 ISO 10646 特別規定在 BMP 以外的字可以轉換成兩個或多個 16 位元的 UCS-2 表示，這種表示或轉換方式稱為 UCS-16，即 UCS Transformation Format 之縮寫。
現在已經被使用的字面，只有第 00 群組前十四個字面用到，因此只需考慮第 00 群組的第 00 字面到第 0E 字面即可。其轉換方式是把 32 位元的 UCS-4 的第 10 個位元到第 15 個位元變成轉換後第一個字組的低 6 位元，UCS-4 的第 16 個位元到第 19 個位元所組成的二進位數減 1，變成轉換後第一個字組的第 6 到第 9 位元，而轉換後的最高 6 位元則固定是 110110；UCS-4 的第 0 位元到第 9 位元變成第二個字組的低 10 位元，高 6 位元固定是 110111。因此 UCS-4 經過 UTF-16 轉換後的高位元組落在 D800～DBFF 之間，低位元組則落在 DC00～DFFF 之間。如下圖：

現在網路傳輸的資料仍大多以 ASCII 編碼的方式傳輸。也就是說，在網路設備如路由器等會去檢查傳輸的資料是否包含 C0 等 ASCII 控制字元，如果有的話，會依狀況處理。因此不管是 UCS-2 或 UCS-4 字元在網路傳輸時，只要含有 C0 控制字元都會被誤認。為了讓 UCS-2 或 UCS-4 字元能安然通過網路設備的檢查，於是 ISO 10646 也規定了 UTF-8 轉換方式。
UTF-8 轉換規則很簡單，如果 USC-4 字元是等於 7F 或小於 7F 以下，則不轉換直接取最低八位元傳送。如果超過 7F 時，則轉換成數個位元組，第一個位元組前面有幾個 1，就代表轉換成幾個位元組，之後接上一個 0，然後從原來的 UCS-4 開始逐一把位元由高而低填上，直到滿了 8 個位元，轉換後的第二個位元組以後前兩個位元必是 10，然後其餘的 6 個位元就是剩餘的 UCS-4 位元依次填上。方法如下：

原來的 UCS-4
字元範圍位元結構經 UTF-8 轉換後
00000000
到
0000007F 第一個字組：
第二個字組：第一個位元組：
00000080
到
000007FF 第一個字組：
第二個字組：第一個位元組：
第二個位元組：
00000800
到
0000FFFF 第一個字組：
第二個字組：第一個位元組：
第二個位元組：
第三個位元組：
00010000
到
001FFFFF 第一個字組：
第二個字組：第一個位元組：
第二個位元組：
第三個位元組：
第四個位元組：
上表說明 UCS-4 轉換後的結果，如果是 UCS-2 的話，就不考慮第一個字組，結果一樣。例如『中』的萬國碼是 4E2D，轉換成二進位是：
0100 1110 0010 1101
4E2D 在 0800 與 FFFF 之間，因此會轉換成 3 個位元組，轉換如下：
第一個位元組：1110 0100 →E4 第二個位元組：1011 1000 →B8 第三個位元組：1010 1101 →AD
第一個位元組的黃色部份有 3 個一，表示 UTF-8 轉換後有三個位元組，其後所接黃色的零表示分隔記號；第二、三最前面黃色的『10』也表示 UTF-8 轉換後的記號。而中的萬國碼的前四個位元是紅色的『0100』就接在 UTF-8 轉換後的第一個位元組後四個位元；而藍色的『1110 00』也就接在第二個位元組之後的 6 個位元；UCS-2 最後的 6 個位元組，就接在第三個位元組的最後 6 個位元。
在 Win XP 的記事本裏，要儲存檔案時，會出現一個『另存新檔』的對話盒，其中『編碼：』複合框就是可以選擇以不同的四種編碼方式存入檔案。如下圖：

其中，ANSI 編碼指的就是以 ASCII 或 Big5 碼方式存入。例如在記事本中有一句『我學Assembly。』字，存檔時，存入的是 ASCII 與 Big5 碼 ( 英文半形字用 ASCII 碼，中文或全形字用 Big5 碼 )，內容如下：
A7 DA BE C7 41 73 73 65 6D 62 6c 79 A1 43
您可以自行到前面提到的地方查『我』、『學』這兩字的 Big5 碼和到附錄四查這些英文字的 ASCII 碼是否符合上面的十六進位數。如果用 Unicode 方式存，則會以 UCS-2 Little-Endian 方式存入，所存入內容為
FF FE 11 62 78 5B 41 00 73 00 73 00 65 00 6D 00 62 00 6C 00 79 00 02 30
最前面兩個位元組是 FF FE，這兩位元組的目的是用來分辨 Big-Endian 還是 Little-Endian。在萬國碼裏，FEFF 是無寬度不中斷空格 ( zero width no-break space )，其 Little-Endian 是 FF FE，而 FFFE 在萬國碼沒有編碼，因此萬國碼是不會出現 FFFE 這種碼的，萬一出現，那就表示是 Little-Endian 編碼。所以 UCS 中建議我們在傳送或儲存萬國碼時，最先傳送、儲存 FEFF 字元，表示 Big-Endian，或者傳送、儲存 FFFE 表示 Little-Endian。而 FEFF 字元經 UTF-8 轉換後變成 EF BB BF，所以前三個位元組是 EF BB BF 的就是 UTF-8 編碼。
接下來的十六進位數，6211、5B78、0041…等分別是『我學A…』的萬國碼，以 UCS-2 Little-Endian 編碼。
如果以 Big-Endian 方式存入時，也是以 UCS-2 編碼方式編碼，但是以大數在前方式排列，因此您會看見與 Unicode 方式存檔時兩兩一組且前後互換，所存內容為
FE FF 62 11 5B 78 00 41 00 73 00 73 00 65 00 6D 00 62 00 6C 00 79 30 02
如果以 UTF-8 方式存檔時，內容就變成：
EF BB BF E6 88 91 E5 AD B8 41 73 73 65 6D 62 6C 79 E3 80 82
您可自行驗證。

SLD歸結法

2012-05-02T19:06:00.001-07:00

1.給定一個目標句 G: -: L1,!L2,...,!Li,...,!Ln
2.選定一個詞 Li
3.選擇一個子句 C: L -: K1,...,Km 使得 Li 及 L 可以一致化，其一致子為 S。
4.將給定子句之尾 K1,...,Km 取代目標句之 Li 部份，並應用一致子 S，
產生新目標句 G1: -: (L1,L2,...,K1,...,Km,...,Ln)S

How to install HDBC-sqlite3 on windows.

2012-03-27T19:31:00.003-07:00

I downloaded sqlite3.dll and sqlite3.h from source zip.

then I inserted sqlite3.dll in system32 dir and in setup configure i used

--extra-lib-dirs=... --extra-include-dirs=... parameters with correct paths to header and dll.

You have a problem it seems. You want to install the Haskell HDBC-sqlite3 library on Windows but you seem to be getting these error messages telling you that it cannot find the required sqlite3 library. The way that you solve this kind of problem is by simply getting your hands on the sqlite3.dll and sqlite3.h files, from here, and putting them in locations that you can then add to the cabal install command later. The ultimate install command should look really simple, something like this:

cabal install HDBC-sqlite3 \
--extra-lib-dirs='C:\some\path\to\sqlite\lib' \
--extra-include-dirs='C:\some\path\to\sqlite\include'

Where you obviously need to set what actual paths get given to those variables.

The only other gotcha that you will need to look out for it to make sure that the sqlite3.dll is always in the path of any program that you make that depends on HDBC-sqlite3 because otherwise it will complain about not being able to find the required dll. Just so that you know, the current directory of any program is always in the current library path.

一致化

2012-01-24T22:48:00.003-08:00

替換：
替換為將變數對映到詞的一對一函數，其表示如下：
{X1/t1, X2/t2,...,Xn/tn}

一致化：
令 s 及 t 為式，若存在替換 T 使得 sT = tT 語義相等，則 s 及 t可以一致化，而該替換 T 稱為 s 及 t 之一致子。

形式一致化問題：

找出可使一組等式集合 ES 之合取 t0 = u0 & t1 = u 1 &...& tn = un 語義相等之替換 S。
此替換稱為該等式集合之一致子。

解式：
為一組等式，等式左側均為不同變數，且不會出現在右側中。
[$x=x,$f=f(x o),$q=q,$s=s]
即為一組解式。

一致化為給定一組等式，並將其轉換成解式之過程。

1.下面形式則表示無法一致化
1.1. f = g 其中f及g 是相異原子。
1.2. f = g 其中f為複合子及g是原子，f為原子及g是複合子。
1.3. f(...) = g(...) 其中f及g 是相異函子。
1.4. f(a1, a2, ..., aN) = g(b1, b2, ..., bM) 其中N及M數目不同。
2.$X=$X 其中$X均為變數，則刪除此等式
3.a=a 其中a均為元式，則刪除此等式4. f(a1, a2, ..., aN) = f(b1, b2, ..., bN) 則用 ai = bi 等式組取代
5.t = X 其中 X 為變數而 t為非變數，則以 X = t取代6.X = t 其中 X 為變數而 t為非變數，且 X 未在 t 中，而存在其它等式中，後把其它等式出現的X 以 t 取代。
7.X = t 其中 X 為變數而 t為非變數，且 X 在 t 中，則因正向變數檢查而無法一致化。
8.若無其它步驟可套用，則一致化成功。

參考資料

2012-01-24T22:36:00.000-08:00

ISO Prolog 語意

前置 '$' 字元之詞視為變數

2012-01-24T22:34:00.000-08:00

前置 '$' 字元之詞視為變數，這是墨辯與Prolog以大寫字元前置視為變數最大之不同。
此項語法參考Perl之用法。