Scheme 学习笔记

schemeLearning

在线版本:
http://docview.cnodejs.net/leaf/notes/scheme/scheme.lx?lx

打算学`Scheme`, 搜了不少尝试去理解, 中文资源不如`JS`多
`IBM`社区`5+`篇文章, 下面两篇介绍语法方面比较清晰
http://www.ibm.com/developerworks/cn/linux/l-schm/index1.html
http://www.ibm.com/developerworks/cn/linux/l-schm/index2.html
关于历史掌故可以看下面这篇了解下, 比较乱, 我没有细看
http://blog.chinaunix.net/space.php?uid=20106293&do=blog&id=142113
`scm`的规范简介有力, 真的很短, 入门后去看下
直接`Google`就能找到 "算法语言`Scheme`修订`5`报告"
教程英文的不少, 中文有本`SICP`的翻译, 算清晰, 爱问搜索有
我搜到`3`份英文教程, 打算只看最简短的第一份了
`Teach Yourself Scheme in Fixnum Days`
http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-1.html
`How to Design Programs: DrScheme Companion` http://www.htdp.org/
`The Scheme Programming Language` http://www.scheme.com/tspl3/
我参照的这份文档只为学会用 scm 解决问题, 大不算深入
然后我很想用上`Scheme`的缩进语法, 希望入门后去看 
http://srfi.schemers.org/srfi-49/srfi-49.html

记得例子不少用`guile`来运行`scm`的, 在脚本开头加两行并可以空行
	#! /usr/bin/env guile
	!#
系统没有 guile 可以在 Ubuntu 安装, 我装的是 1.8 版本
然后脚本我不重复了, 开头缩进是笔记格式, 代码参考原文
	;The first program
	(begin
		(display "Hello")
		(newline))
分号开头进行注释, `begin`表示后边多个模式
`display`是向`console`输出, `newline`是输出新的换行
教程说的`mzscheme`不清楚, `Ubuntu`里面用的`guile`
实际上我用的命令是`$ rlwrap guile`
然后输入`load "hi.scm"`(点钱目录文件名)运行该脚本
`guile`中的`prompt`是`guile>`, 这里直接输入代码
在`prompt`中输入`"hi"`会直接输出内容
两种方式有区别, 向`console`输出对于函数是种副作用
而`"hi"`则是计算得到结果的
文章约定`=>`表示模式运算后给出结果
可以用`(exit)`退出`guile`命令行, `Linux`常快捷键`C^d`
运行脚本可以用`guile -s hi.scm`

@`scm`有布尔, 数值, 字符, 符号几个数据类型
真: `#t`, 假: `#f`, 判断是否布尔类型: `boolean? #t`
否定: `(not #t) ;=> #f`
`scm`中数值类型有整数, 分数, 实数, 复数
各自有`number? complex? real? rational? integer?` 判断
整数未必十进制, 前缀`#b #o #x`分别表示二, 八, 十六进制
比如`#b100`是二进制的`100`, 十进制的`4`
判断大小是否相等用`(eqv? 2 #b10) => #t``(eqv? 2 2.0) => #f`
这个广义的判别函数对于不同类型不会报错`(eqv? 2 #f) => #f`
另外有个针对数值的判别符`(= 42 42.0) => #t`
而这个判别符对于数值外内容会报错, 比如`(= 2 #f)`
对于数字的大小判断还有`> < >= <=`可用
运算符号有`+ - * /`, 都支持一个或多个参数
其中除法结果是分数
`(expt 2 3)`表示乘方, 只有两个参数
`min max abs exp atan sqrt`等都可以推测
`scm`的字符以`#\`开头比如`#\c`是字符`c`
一般是在后面跟一个字符, 但也有用多个字母描述的比如
`#\newline #\tab #\space`, 也有`#\ `表示空格
字符的判别: `char? #\c ;=> #t`, 字符还有大小的判别
`char<? char<=? char=? char>=? char>?`
为忽略大小写用`(char-ci=? #\A #\a) => #t`, 以此类推
字母大小写转换用`char-downcase char-upcase`
前面这些比如`#t 42 #\c`自求值的内容
符号被输入到解释器里, 给出运算结果一般就是本身
符号类型不同, 因为同样的内容常被用作变量标识符
意味着那会被计算, 并返回计算结果的内容
但符号依然是基本的数据类型, 可以和其他类型交换
在`scm`里用上`(quote xyz) => xyz`标记符号
符号非常常用, 于是有了简写`'E`相当于`(quote E)`
符号的表示以不被混淆为准, `<=>`和'$!#*'都行
但像这些`#t "aString" -i`就不行了
可以用`(symbol? 'xyz)`判别
注意`scm`里对大小写不敏感, 这里不例外
接着可以定义符号为变量`(define xyz 9)`
在解释器里输入就会直接返回内容了`xyz ;=> 9`
或者用`(set! xyz #\c)`这样
复合数据类型由数据类型俺结构组合而成
字符串是自求值的`"Hello" => "Hello"`
该程序由一系列字符组成`(string #\H #\e #\l #\l #\o)`
用`(string-ref "abcd" 1)`取出序号`1` 的元素
用`(string-append "a" "b" "c")`来组合新的字符串
可新建指定长的空字符串`(make-string 3) ;=> "\x00\x00\x00")`
如果`(define s (make-string 3))`
那么再给`s`赋值就注意不能越界
`(string-set! s 0 #\s)`用来修改指定序号的字符
向量可以容纳各种类型, 包括向量自身
定义向量: `(vector 1 2 3) ;=> #(1 2 3)`
也可以直接使用`#(1 2 3)`产生向量
类似有`(make-vector 5)`来生成限定长度的向量
类似有`vector-ref vector-set vector?`
@点对用来组合任意两个值, 前者称`car`, 后者`cdr`
组合两者的程序是`(cons 1 #\t) ;=> (1 . #\t)`
简洁的定义的方式`'(1 . #\t)`
	(define x '(1 . #\t))
取出内容通过`(car x)`或者`(cdr x)`
设置: `(set-car! x)`和`(set-cdr! x)`
	(define y (cons (cons 1 2) 3)) ;=> ((1 . 1.0) . 2))
	(define y (cons 1 (cons 2 3))) ;=> (1 2 . 3)
`(cdr (car y))`可以简化成`(cdar y)`最多四层
	(cons 1 (cons 2 (cons 3 (cons 4 5)))) ;=> (1 2 3 4 . 5)
有个空的点对`'() ;=> ()`
	'(1 . (2 . (3 . (4 . ())))) ;=> (1 2 3 4)
	(cons 1 (cons 2 (cons 3 (cons 4 '())))) ;=> (1 2 3 4)
还有个程序: `(list 1 2 3 4) ;=> (1 2 3 4)`
还有: `'(1 2 3 4) ;=> (1 2 3 4)`
	(define y (list 1 2 3 4))
	(list-ref y 0) ;=> 1
	(list-ref y 3) ;=> 3
	(list-tail y 1) ;=> (2 3 4)
	(list-tail y 3) ;=> (4)
	(pair? '(1 . 2)) ;=> #t
	(pair? '(1 2)) ;=> #t
	(pair? '()) ;=> #f
	(list? '()) ;=> #t
	(null? '()) ;=> #t
	(list? '(1 2)) ;=> #t
	(list? '(1 . 2)) ;=> #f
字符串和数值间通过`ASIIC`码互转, 其他较明显
	(char->integer #\d) ;=> 100
	(integer->char 50) ;=> #\2
	(string->list "hello") ;=> (#\h #\e #\l #\l #\o)
	(number->string 16) ;=> "16"
	(string->number "16") ;=> 16
	(string->number "hi") ;=> #f
	(symbol->string 'symbol) ;=> "symbol"
	(string->symbol "string") ;=> string
基于基数的转化, 比如下面基于八进制
	`(string->number "16" 8)`
`scm`还有个过程类型`procedure`, 目前看到都是基本过程
基本过程在环境被支持, 也有途径创建自己的过程
另有种数据类型`port`端口, 关联文件和终端的输入输出
比如`display`还有个隐含的参数, 表示输出的端口
`(display "Hello, World!" (current-output-port)`

`scm`解释器会探测每一个形式`(form)`首个符号
如果那是过程, 就会将其余作为参数执行这个形式
像`begin define set!`是一些特殊形式, 特殊行为
用户可以通过`lambda`表达式创建过程
	(lambda (x) (+ x 2))
	((lambda (x) (+ x 2)) 5) ;=> 7
	(define add2 (lambda (x) (+ x 2)))
	(add2 4) ;=> 6
	(define area
		(lambda (length breadth)
			(* length breadth)))
	(define area *) ;=> 同上
`apply`可以运行一个过程, 并载入指定参数
可以载入多个参数, 但必须要列表作为参数结尾
	(define x '(1 2 3))
	(apply + x) ;=> 2
	(apply + 1 2 3 x) ;=> 12
`begin`用来俺顺序执行参数中的子形式
而`lambda`内部也是顺序执行的:
	(define display3
		(lambda (arg1 arg2)
			(display arg1)
			(newline)
			(display arg2))

条件语句`if`, `else`是隐含的
	(if #t
		(display "true"))
	(if (> 1 0)
		(display "true")
		(display "false"))
`when`用来判断, 当为真, 按顺序执行子形式
`unelss`把`when`的条件取反, 然后顺序执行
不过两者在`guile`里用不出来, 不考虑了
`cond`用于判别, 每个参数都有判别是和结果
有可选的`else`, 相似有`case`, 看例子的括号
	(define c #\c)
	(cond ((char<? c #\c) -1)
		((char=? c #\c) 0)
		(else 1)) ;=> 0
	(case c
		((#\a) 1)
		((#\c) 2)
		(else 3))
`and or not`对应: 且, 或, 非
不过在`guile`对于多个值或其他类型参数就要出错
	(and #\t #\f) ;=> #\f
	(or #\t #\f) ;=> #\t

@`scm`的变量作用域是词法域, 静态作用域
全局变量不受局部变量的影响, 看例子
	(define x 9)
	(define add 2 (lambda (x) (+ x 2)))
	x ;=> 9
	(add2 3) ;=> 5
	x ;=> 9
而`(set! x 20)`能对全局变量进行修改
`scm`会选取词法上(?)最近的变量进行使用
	(define counter 0)
	(define bump-counter
		(lambda ()
			(set! counter (+ counter 1))
			counter))
	(bump-counter) ;=> 1
	(bump-counter) ;=> 2
`let`可以新建局部变量, 遮盖全局变量, 注意写法
	(define x 20)
	(let (
		(x 1)
		(y 2))
		(list x y)) ;=> (1 2)
	(let (
		(x 1)
		(y x))
		(list x y)) ;=> (1 20)
考虑到`let*`还有下面的写法
	(let* ((x 1)
		(y x))
		(+ x y)) ;=> 2
	(let ((x 1))
		(let ((x y))
			(+ x y))) ;=> 2
	(let ((cons (lambda (x y) (+ x y))))
		(cons 1 2)) ;=> 3
`fluid-let`会临时修改全局变量值, 过后复原
但是这个在`guile`里头也是不对劲的(?)
而`let`本身面对这样的过程处理不同
	(define x 0)
	(define x+
		(lambda ()
			(set! x (+ x 1))
			(display x)))
	(let ((x 20))
		(x+)) ;=> 1

@递归, 调用自身, 转化条件, 设定边界, 看例子
	(define fractorial
		lambda (n)
			(if (= n) 1
				(* n (fractorial (- n 1)))))
	(define is-even?
		(lambda (n)
			(if (= n 0) #t
				(is-odd? (- n 1)))))
	(define is-odd?
		(lambda (n)
			(if (= n 0) #f
				(is-even? (- n 1)))))
其实`scm`已经内置`even? odd?`两个过程
注意在局部变量实现`is-even? is-odd?`会有问题
用`let`时`if`内部的`is-even? is-odd?`不能正确指向
用`let*`时`if`内部的`is-odd`不能正确指向
于是引入了新的过程`letrec`进行
	(letrec ((local-even? (lambda (n)
		(if (= n 0) #t
			(local-odd? (- n 1)))))
		(local-odd? (lambda (n)
			(if (= n 0) #f
				(local-even? (- n 1))))))
		(list (local-even? 23) (local-odd? 23)))
`letrec`是专门为定义递归和相互递归的局部过程设计的
借助`letrec`实现的循环过程
	(letrec ((countdown (lambda (i)
		(if (= i 0) 'liftoff
			(begin
				(display i)
				(newline)
				(countdown (- i 1)))))))
		(countdown 10))
这一段可以用宏用`let`写更紧凑的结构
	(let countdown ((i 10))
		(if (= i 0) 'liftoff
			(begin
				(display i)
				(newline)
				(countdown (- i 1)))))
`scm`中不存在递归以外其他循环和迭代的构造
递归会被关照以免开销过大(?)
前面的递归是尾部递归, 尾递归可以被优化, 因而安全
例子, 尾递归实现, 从列表`l`取元素`o`位置, 否则返回`#f`
例子, 递归倒转列表内容的顺序
	(define reverse!
		(lambda (s)
			(let loop ((s s) (r '()))
				(if (null? s) r
					(let ((d (cdr s)))
						(set-cdr! s r)
						(display d)
						(display ", ")
						(display s)
						(newline)
						(loop d s))))))
几个小时才看明白, 还好环境里一般会提供这个函数的
有一类迭代多次重复, 就是遍历列表每个元素
于是有`map for-each`两种操作, 前者熟悉的
	(define add2 (lambda (x)
		(+ x 2)))
	(map add2 '(1 2 3)) ;=> (3 4 5)
	(map cons '(1 2 3) '(10 20 30)) ;=> ((1 .10) (2 . 20) (3 30))
	(map + '(1 2 3) '(10 20 30)) ;=> ( 11 22 33)
而后者没有返回值, 是副作用
	(for-each display '(1 2 3 4))

`scm`的读取端口的参数是可选的, 默认是`console`
读取内容以字符, 行, `S 表达式`为单位
以某种`EOF`结束, 才能用`eof-object?`判断结束
函数有`read-char read-line read`, 后者读取`S 表达式`
写入的端口也是可选的, 默认`console`
写入的单位可以是字符, 或者基于`S 表达式`
`write-char`写出的时候不会有`#\`前置, 保留机器方便的格式
`display`的功能类似, 但会更方便人们阅读
`open-input-file`过程接收文件名, 返回输出端口
	(define i (open-input-file "hello.txt"))
	(read-char i) ;=> #\h
	(define j (read i))
	j ;=> ello
如果原文件不存在, `close-output-file`会建立新文件
运行代码发现`output input file port`易混淆, 注意
	(define o (open-output-file "g.txt"))
	(display "hello" o)
	(write-char #\space o)
	(display 'world o)
	(newline o)
	(close0output-port o)
`call-with-input-file`和`call-with-output-file`自动管理关闭
	(call-with-input-file "hello.txt"
		(lambda (i)
			(let* ((a (read-char i))
				(b (read-char i))
				(c (read-char i)))
			(list a b c)))) ;=> (#\h #\e #\l)
未来操作字符串方便有`open-input-string open-output-string`
	(define i (open-input-string "hello world"))
	(read-char i) ;=> #\h
	(read i) ;=> ello
	(read i) ;=> world
	(define o (open-output-string))
	(write 'hello o)
	(write-char #\, o)
	(display " " o)
	(display "world" o)
	(get-output-string o) ;=> "hello, world"
还有`load load-ralative`两个形式, 解说比较复杂(?)

宏按说明应该像重用的代码块的缩写之类, 像链接用
	(defint-macro when
		(lambda (test . branch)
			(list 'if test
				(cons 'begin branch)))))
用`define-macro`定义, 结果是
	(when (< 1 2)
		(display "true 1\n")
		(display "true 2\n"))
相当于代入其中转化成为
	(if (< 1 2)
		(begin
			(display "true 1\n")
			(display "true 2\n")))
同样有`unless`的使用, 甚至在其中使用已经定义的`when`
	(define-macro unless
		(lambda (test . branch)
			(list 'if
				(list 'not test)
				(cons 'begin branch))))
	(define-macro unless
		(lambda (test . branch)
			(cons 'when
				(cons (list 'not test) branch))))
用反引号还可以简化语法, 大概`guile`对大小写敏感
其中`,`表示插入相应的值, `,@`表示插入相应`S 表达式`
	(defin-macro when
		(lambda (test . branch)
			`(if ,test
				(begin ,@branch))))
当用下面这种方式实现一个`or`形式
	(define-macro my-or
		(lambda (x y)
			`(if ,x ,x ,y)))
	(my-or 1 2) ;=> 1
	(my-or #f 2) ;=> 2
	(my-or
		(begin
			(display "twice")
			(newline)
			#t)
		2)
上面因为求值过程, 会出现两次`display`, 改写
	(define-macro my-or
		(lambda (x y)
			`(let ((temp ,x))
				(if temp temp ,y))))
再改写用来形成私有的调用, 甚至用`gensym`产生私有的符号
	(define-macro my-or
		(lambda (x y)
			`(let ((+temp ,x))
				(if +temp +temp ,y))))
	(define-macro my-or
		(lambda (x y)
			(lat ((temp (gensym)))
				`(let ((,temp ,x))
					(if ,temp ,temp ,y)))))
`? 8.3 的 fluid-let 在 guile 没有, 正好跳过`

后边`Mzscheme`和`guile`差别较大, 加上难度, 放弃了