main ::= {tree}
tree ::= '(' id leaf ')'
leaf ::= exps | main
exps ::= [{exp}]
exp  ::= id | bool | num | str | arr | low
id   ::  [^#\.\d\(\)\[\]\{\}'"`,;+-][^\s\(\)\[\]\{\}'"`,;]*
bool ::  #t|#f|#T|#F
num  ::  [+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?
str  ::  '\'' [{chr}] '\'' | '"' [{chr}] '"'
low  ::  #[^\s\(\)\[\]\{\}'"`,;]*
chr  ::= any-Unicode-character-except-"-or-\-or-control-character | 
		\" | \\ | \0 | \b | \7 | \f | \n | \r | \t | \v | 
		\x two-hex-digits | \u four-hex-digits
number
arr  ::= '[' arrc ']'
arrc ::= [{exp}]
comt ::  ^\s*#.*$

## 这些全是正则表达式
id   ::  [^#\.\d\(\)\[\]\{\}'"`,;+-][^\s\(\)\[\]\{\}'"`,;]*
bool ::  #t|#f|#T|#F
num  ::  [+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?
str  ::  '\'' [{chr}] '\'' | '"' [{chr}] '"'
low  ::  #[^\s\(\)\[\]\{\}'"`,;]*
main ::  \(
end  ::  \)
arr ::  \[
narr ::  \]

// 这个函数就可以完成这样的工作
// ssub(string, pattern) 同时返回 pattern 匹配 string 后的结果和余下的字符串
function ssub (s, p) {
	var ss = p.exec(s)[0]
	return [ss, s.slice(ss.length)]
}
// 弹出下一个单词
function word (s) {
	return ssub(s, /^[^\s\(\)\[\]\{\}'"`,;]+/)
}
// 弹出下一个“东西”，仅用于报错
function gew (s) {
	return /^[^\s\(\)\[\]'"]+/.exec(s)[0]
}
// 还真的报错了
function error (m, ln) {
	throw Error (m+" in line "+ln)
}

	// 先给出判断语法元素的函数，它们的参数是剩余的字符串
	// 剩余的字符串没有了，整个代码也到头了
	function isEOF (c) { return c == "" }
	function beLine (c) { return c[0] == '\n' }
	function beSpase (c) { return /\s/.test(c[0]) }
	function beId (c) { return /[^#\.\d\(\)\[\]\{\}'"`,;+-]/.test(c[0]) }
	function beBool (c) { return c[0] == '#' }
	function beNum (c) { return /[-+\d\.]/.test(c[0]) }
	function beStr (c) { return c[0] == '\'' || c[0] == '\"' }
	function beMain (c) { return c[0] == '(' }
	function beEnd (c) { return c[0] == ')' }
	function beArr (c) { return c[0] == '[' }
	function beNarr (c) { return c[0] == ']' }

/* 基本函数 */
// 连接项目与列表
function cons (o, l) {
	return [o].concat(l)
}
// 取列表除去第一项后余下的部分
function cdr (l) {
	return l.slice(1)
}
// 消除左侧除换行之外的空白
function strim (s) {
	return s.replace(/^\s+?(?=\n)?/,'')
}

/* 词法分析器 */
// 标准的正则尾递归优化写法。尽管 JavaScript 不支持优化，但不失为一种很好的组织程序的手段
// 使用时调用 slex(string, [], 1)，参数 t 用来暂存分析数组
function slex (s, t, ln) {
	if (isEOF(s)) return t.reverse()
	var tmp = []
	// 用 ln 参数保存行数
	if (beLine(s)) return slex(cdr(s), ln+1)
	if (beSpase(s)) return slex(strim(s), ln)

	else if (beBool(s)) tmp = bool(s, ln)
	else if (beNum(s)) tmp = num(s, ln)
	else if (beId(s)) tmp = id(s, ln)
	else if (beStr(s)) tmp = str(s, ln)
	else if (beMain(s)) tmp = main(s, ln)
	else if (beEnd(s)) tmp = end(s, ln)
	else if (beArr(s)) tmp = arr(s, ln)
	else if (beNarr(s)) tmp = narr(s, ln)
	else error("Unknown Value: "+gew(s), ln)

	return slex(tmp[1], cons(tmp[0], t), tmp[2])
}

/* 所有的词法元素的解开过程 */
// 每个函数返回的第三个值是新的行号
// 此处省略，详见附件源代码 179-222 行
// 源代码中 arr、narr、main、end 几个函数都是语法分析的版本，
// 以 arr 举例说明这一系列函数的共性
function arr (s, ln) {
	return ['[', cdr(s), ln]
}
// 其他的函数只不过是使用了 ssub() 函数通过正则表达式解析了而已。

main ::= {tree}
tree ::= '(' id leaf ')'
leaf ::= exps | main

tree ::= '(' id exps | {tree} ')'

// e 代表为空，对应的希腊字母
// 当然也可以消除 e，把为空表现在上级产生式中
main ::= tree | tree main
tree ::= '(' id leaf ')'
leaf ::= exps | main
exps ::= e | exp | exp exps
exp  ::= id | bool | num | str | arr | low
arr  ::= '[' arrc ']'
arrc ::= e | exps

// 参数 ls 是词法分析结果
function sdict (ls) {
	var index = ["~"]  //对象树节点名的线型访问栈
	var root = {}      //全局的对象树
	var stack = [root] //对象树节点的线型访问栈

	// 对照 BNF，不难发现解开递归的技巧：
		/* 把对起始符和终结符的处理写在函数中，递归部分一直向下推迟，
		   直到 exps 这个产生式被终结时再调用回 main() */
	// main ::= tree | tree main
	function main (ls, ln) {
		if (ls == false)
			if (!canPop(stack))
				return
			else error("Lack of end quotes", ln)
		else if (beMain(ls[0]))
			tree(cdr(ls), ln)
		else if (beEnd(ls[0]))
			if (canPop(stack)) {
				// 语法分析 main 结束就弹出一个数据栈，一条树枝结束了
				stack.pop()
				main(cdr(ls), ln)
			}
			else error("To many end quotes", ln)
		else error("Wrong Syntax: "+ls[0], ln)
	}

	function tree (ls, ln) {
		// 这是一个一步推导产生式的例子
		// tree ::= '(' id leaf ')'
		if (beId(ls[0])) {
			var tmp = id(ls[0])
			// 这些就是插入的全局数据结构更新代码，向栈中增加索引
			add_index(stack, tmp[0])
			leaf(tmp[1], ln)
		}
		else error("Not an Id: "+ls[0])
	}

	/* 详细参见源文件74-143行，把每个函数处理空白的代码去掉，
	   参数s替换为 ls，函数体内替换为 ls[0] 就是独立语法分析的版本。 */
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师

function People () {
	var money = 0
	function setMoney (dollars) {
		money = dollars
	}
	function pay (dollars) {
		money -= dollars
	}
	return (function (verb) {
		return eval(verb)
	})
}

function Fool (iq) {
	var IQ = iq || 0
	function init (iq) {
		IQ = iq
	}
	return (function (verb) {
		try {
			return eval(verb)
		} catch (e) {
			return People()(verb)
		}
	})
}

Fool = extend('People()', function (iq){
	var IQ = iq || 0
	function init (iq) {
		IQ = iq
	}
})

var origin = People()

function () {
	return (function (origin) {
		var IQ = 0
		function init (iq) {
			IQ = iq
		}
		return (function (verb) {
			try {
				return eval(verb)
			} catch (e) {
				return origin(verb)
			}
		})
	})(People())
}

function extend (originc, code) {
	function argsArea (code) {
		// 题外话，正则表达式也有不值得一用的时候
		return code.slice(code.indexOf('(')+1, code.indexOf(')'))
	}
	function bodyCode (code) {
		// 不用 trim() 了，别没事儿找事儿
		return code.slice(code.indexOf('{')+1, code.lastIndexOf('}'))
	}
	function format (body) {
		var objc = bodyCode(function () {
			return (function (verb) {
				try {
					return eval(verb)
				} catch (e) {
					return origin(verb)
				}
			})
		}.toString())
		return 'return (function (origin) {'+body+objc+'})('+originc+')'
	}
	var $ = code.toString()
	return Function(argsArea($), format(bodyCode($)))
}

if (arguments.length == 1) {
	code = originc
	originc = 'AbsObj()'
}

function AbsObj () {
	//检测是否能响应此 verb，要再用一次异常处理
	function canHandle(verb){
		try {
			// 别担心这里的 self 会传递不过去
			self(verb)
		} catch (e) {
			return false
		}
		return true
	}
	function toString() {} // 这个搞起来其实很麻烦~`
	var self = function (verb) {
		return eval(verb)
	}
	return self
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

sort [] = []
sort (x:xs) = sort [y | y <- xs, y < x] ++ [x] ++ sort [y | y <- xs, y >= x]

# 得到一个 2 到 20 中的偶数组成的列表，只要写
>>> [x for x in range(2, 21) if x % 2 == 0]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# 记住，只需给出一个形式，比方说想求两个列表的“笛卡尔乘积”
>>> [(x , y) for x in range(4) for y in [3,1,7,8]]

def sort (ls): 
　　return [] if ls == [] \
　　　else sort([y for y in ls[1:] if y < ls[0]]) + \
　　　[ls[0]] + \
　　　sort([y for y in ls[1:] if y >= ls[0]])
　　# 别忘了 python-2.5 的新特性条件分支表达式哦！可惜太长，不得不强制换行。

def queens (row, col):
　　return [[]] if col == 0 \
　　　else [[ran] + rst \  # 在 Python 中，g(x,y)=[x]+y 
　　　for ran in range(row) \
　　　for rst in queens(row, col - 1) \
　　　if safe(ran, rst)]

　　def check (pos):
　　　　# 表达式变个形式，少打点字
　　　　return not (ran == rst[pos] or abs(ran - rst[pos]) == pos + 1)

def safe (ran, rst):
　　def check (pos):
　　　　return not (ran == rst[pos] or abs(ran - rst[pos]) == pos + 1)
　　return ands([check(pos) for pos in range(len(rst))])

def ands (ls):
　　return True if ls == [] \
　　　else (False if not ls[0] \
　　　else ands(ls[1:]))

>>> queens(4,4)
[[1, 3, 0, 2], [2, 0, 3, 1]]

	[[ran] + rst \
　　　for ran in range(row) \
　　　for rst in queens(row, col - 1) \
　　　if safe(ran, rst)]

def flatmap (opt, ls):
　　# 小技巧：累积器在连接列表时可以不用 lambda x,y: x+y，直接用 list.__add__，
　　# 重点是类型出错时有报警
　　return reduce(list.__add__, map(opt, ls))

def newcol (rst):
　　# 顺手解决 filter 只能传递一个参数的限制，用 lambda 代掉
　　return filter(lambda ls: safe(ls[0], rst), map(lambda x: [x] + rst, range(row)))

def safe (ran, rst):
　　return every(check, range(len(rst)))
# every() 函数相当于打过兴奋剂的 ands
def every (test, ls):
　　return True if ls == [] \
　　　else (False if not test(ls[0]) \
　　　else every(test, ls[1:]))

• 函数式编程的思想描述算法绝对强，无论是列表领悟还是通用列表操作都十分清晰，仿佛能感受到数据在表达式间游动；
• 和平起见，就不把我那个传说中的只有一行代码的版本拿来和几十行的命令式风格的代码比较了，但大家应该心领神会；
• 有时候，把问题想的简单一些，思维更“形而上学”一些，反而能更快的得到解决问题的思路，顺着思路再改进也不迟；
• Python 的表达式版的分支语句很漂亮，但被该死的换行限制给玷污了；另外列表领悟实现得够烂，眼下只能是玩玩儿。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 扩展的克里化函数
• 运算符函数化
• 紧缩的匿名函数语法
• 无须指定参数的匿名函数语法
• 函数向导语法
• 基本的通用列表操作
• 部分扩展基于对象化

• 尾递归优化
• 模式匹配（包括参数匹配、列表匹配、情况分析）
• 惰性运算（包括无穷列表）
• 列表领悟
• 扩展绑定、同时绑定
• 其它列表操作（以及对于列表操作的基于对象化）

1. 全局操作，绑定在全局对象 Functional 上，主要是高阶函数操作和列表操作，所谓库安装即把这些内容可选的、安全地复制到全局环境
2. 函数扩展，实现特殊高阶函数特性的工具（特供内部）
3. 语法扩展，绑定在 String.prototype 上，负责将字符串表示的 lambda 语法翻译为相应的高阶函数（特供内部）

Functional.install = function(except) { // except 参数是一个对象，不加载这些操作 
    var source = Functional,
        target = window; // 复制操作到全局环境 window，仅限于浏览器环境
    for (var name in source)
        name == 'install' // 当然，不能把 install 复制到 source
        || name.charAt(0) == '_' // 命名开头为 _，私有属性
        || except && name in except
        || {}[name] // work around Prototype
        || (target[name] = source[name]);
}

1. map(f, [x1, x2...]) = [f(x, 0), f(x2, 1), ...]
2. foldl, reduce(f, init, [x0, x1, x2]) == f(f(f(init, x0), x1), x2)
3. filer, select('%2', [1,2,3,4]) -> [1, 3]
4. foldr(f, init, [x0, x1, x2]) == fn(x0, f(x1, f(x2, init)))
5. some(f, [x1, x2, x3, ...]) == f(x1) || f(x2) || f(x3)...
6. every(f, [x1, x2, x3, ...]) == f(x1) && f(x2) && f(x3)...

Function.prototype.curry = function(/*args...*/) {
    var fn = this;
    var args = [].slice.call(arguments, 0);
    return function() {
        return fn.apply(this, args.concat([].slice.call(arguments, 0)));
    };
}

• rcurry，对从右边开始缺少参数的函数作克里化
• ncurry，不接受全部参数就不 apply 参数的版本
• rncurry，前者的反序版本
• uncurry，作者一再强调，这不是 curry 的反转版本。它会拆分出第一个已得参数，形式为：f.uncurry(a, b...) == f(a)(b...)

Functional.until = function(pred, fn) {
　　// 使用时参数会被强制转为 Functional 的函数，参数可为字符串
    fn = Function.toFunction(fn); 
    pred = Function.toFunction(pred); 
　　// 返回一个接受一个参数的函数，
    return function(value) {
　　　　// 它不断对此参数 apply 函数 pred，
        while (!pred.call(null, value))
　　　　　　// 并用 fn(value) 的值更新 value，
            value = fn.call(null, value);
        return value; // 直到测试结果为 true。
    }
}

Functional.__initalFunctionState = 
Functional._startRecordingMethodChanges(Function.prototype);

String.prototype.lambda = function() {
    var params = []; // 存储字符串形式的参数的列表
    var expr = this;
　　// ECMAsplit 是作者为兼容 IE6.0 所写的 split 版本
    var sections = expr.ECMAsplit(/\s*->\s*/m); // 使字符串被 '->' 分割
　　/* 注意，分割的结果支持超过任意个 '->'，下面会发现，
　　　　-> 9 或者
　　　　x -> y -> x+y 这样的代码也会被正确理解。
　　*/
    if (sections.length > 1) {
　　　　// 这就是所谓的“正确理解”了
        while (sections.length) {
            expr = sections.pop();
　　　　　　// 然后把参数打碎，再重组为 JS 可识别的参数语法
　　　　　　/* 也就是说，x y -> x*y+2 和
　　　　　　　　x,y -> x*y+2 都可被接受。
　　　　　　*/
            params = sections.pop().split(/\s*,\s*|\s+/m);
　　　　　　// 装配成代码，顺便支持尾递归语法
            sections.length && sections.push('(function('+params+'){return ('+expr+')})'); 
        }
    } else if (expr.match(/\b_\b/)) {
        params = '_'; // 忽略参数的前奏，下文判断
    } else {
　　　　// 这里处理运算符表达式参数缺失的情况，相当于运算符函数化
　　　　// 分为前缺失和后缺失两种情况，
        var leftSection = expr.match(/^\s*(?:[+*\/%&|\^\.=<>]|!=)/m);
        var rightSection = expr.match(/[+\-*\/%&|\^\.=<>!]\s*$/m);
　　　　/* 注意，前缺失类似 *2，后缺失类似 2*，复杂表达式同样支持
　　　　　　此外，前后都缺失也可以，比如 * 甚至是 *3*
　　　　*/
        if (leftSection || rightSection) {
　　　　　　// 翻译缺失代码的技术：用 $1、$2 代换参数
            if (leftSection) {
                params.push('$1');
                expr = '$1' + expr;
            }
            if (rightSection) {
                params.push('$2');
                expr = expr + '$2';
            }
        } else {
　　　　　　// 这个地方就有点意思了；它使得函数支持参数指定缺失
　　　　　　/* 比如 x*y 就已经是一个函数了，相当于 x y->x*y
　　　　　　　　作者还特别防止了一个 bug，即对象属性访问语法中，
　　　　　　　　属性部分不被认为是未指定的参数。例如
　　　　　　　　obj.pro + 4 这个函数，只有 obj 一个参数
　　　　　　　　而且，this 和 arguments 不会被认为是未知数。
　　　　　　*/
            var vars = this.replace(/(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|this|arguments|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g, '')
			.match(/([a-z_$][a-z_$\d]*)/gi) || []; 
            for (var i = 0, v; v = vars[i++]; )
                params.indexOf(v) >= 0 || params.push(v);
        }
    }
    return new Function(params, 'return (' + expr + ')'); // 把代码装配成函数对象
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

qsort [] = []
qsort (x:xs) = qsort lt ++ [x] ++ qsort st
	where lt = [y | y <- xs, y < x]
		st = [y | y <- xs, y >= x]

1. 第一句，指定函数取值点。相对于数学中描述函数在某点取值的语法。对于普通的语言，可以用 if 语句代替。
2. 参数 (x:xs)，是参数领悟特性。指的是，此参数是一个由元素 x 开头，剩余部分为 xs 组成的列表。对于普通的语言，可以用在函数内部绑定参数的分解结果的方法代替。
3. 列表连接运算符 ++，用 append 函数代替。
4. where 语句，后置变量说明。用前置 let 绑定代替。
5. 类似 [y | y <- xs, y < x] 的列表领悟。对于单元素的领悟，用 filter 函数过滤，过滤规则表示为 lambda 函数，它对于 y < x 返回 true。

;; 使用 SICP 中描述的 filter 函数，就不抄在这儿了
(define (qsort ls)
	(if (null? ls) '()
		(let
			((x (car ls))
			(xs (cdr ls)))
			(let 
				((lt (filter (lambda (y) (< y x)) xs))
				(st (filter (lambda (y) (>= y x)) xs)))
				(append (qsort lt) (list x) (qsort st))))))

1. 取列表首项函数 car，用 Array[0] 代替。
2. 取列表剩余项函数 cdr，用 Array.slice(1) 代替。
3. 判断列表是否为空函数 null?，用 ls == false 代替（JS 的特殊之处）。
4. 变量绑定语法 let，仅用声明变量语法 var 代替（千万不能不用）。// 在 JavaScript 1.6 中加入了 let 关键字，爽一点；还有列表领悟，无语了！
5. 过滤器函数 filter。为快一点起见，自己用命令式风格写一个绑定在 Array.prototype 上。
6. 匿名函数 lambda，不就是匿名 function 嘛！
7. 列表连接函数 append，用 Array.concat() 代替。

// 把要用到的表达式抽象出来
Array.prototype.head = function () {
    return this[0];
}

Array.prototype.tail = function () {
    return this.slice(1);
}

Array.prototype.filter = function (proc) {
    var tmpArr = [];
    for (var i = 0; i < this.length; i++)
	if (proc(this[i]) == true)
	    tmpArr.push(this[i]);
    return tmpArr;
}

Array.prototype.qsort = function () {
	if (this == false) return []
	var x, xs, lt, st
	x = this.head()
	xs = this.tail()
	lt = xs.filter(function (y) {return y < x})
	st = xs.filter(function (y) {return y >= x})
	return lt.qsort().concat([x], st.qsort())
}

function qsort (arr, l, u) {
    l = l || 0;
    u = ((u != 0) && (u == undefined)) ? arr.length : u;
    if (l >= u) return;
    var m = l;
    for (var i = l+1; i <= u; i++)
	if (arr[i] < arr[l])
	    arr.swap(++m, i);
    arr.swap(l, m);
    qsort(arr, l, m-1);
    qsort(arr, m+1, u);
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

kaf a b c d = 
	((sqr ((a * d) - (b * c))) * (a + b + c + d)) / 
		((a + b) * (c + d) * (a + c) * (d + b))

-- sqr 函数是用来求一个数的平方的，再实现一下：
sqr n = n * n

lrb xl yl = 
	-- 这里要注意一下，数学中的 sigma 是一种记法而非函数
	(sigma
	 (\(x, y) -> (x - xp) * (y - yp)) (zip xl yl)) /
		sigma (\x -> sqr (x - xp)) xl 
	where 
		xp = avg xl
		yp = avg yl

lra xl yl = avg yl - (lrb xl yl) * avg xl

avg ls = sum ls / len ls

len [] = 0
len (x:xl) = (len xl) + 1

sigma f (x:xl) = 
	if xl == []
	then f x
	else f x + sigma f xl

lrr xl yl = 
		(sigma 
	 (\(x, y) -> (x - xp) * (y - yp)) (zip xl yl)) /
		sqrt ((sigma (\x -> sqr (x - xp)) xl) * 
		 (sigma (\y -> sqr (y - yp)) yl))
	where 
		xp = avg xl
		yp = avg yl

• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

for (var i = 0; i < 10; i++) {
	var f = function (a) {
		return a * a
	}
	print(f(i))
}

• 二者从程序的源代码文本的同一处获取其函数体
• 在使用 eval() 函数从产生程序时，二者从其参数的同一处获取其函数体

• 进入执行上下文，重命名内部绑定的变量，用中间代码翻译所有函数体，若存在中间代码相同的函数，认为它们是同一个函数
• 在使用 eval() 函数从产生程序时……（略）

1. 查找本级作用域是否包含该变量的绑定
2. 如果 Result(1) 为假，转到 Step4
3. 返回本级作用域中该变量的绑定
4. 如果本级作用域是全局作用域（顶层），报错
5. 对上级（调用环境）作用域应用 Step1

(define (fact n)
	(if (= n 0)
		1
		(* n (fact (- n 1)))))

• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

typedef struct{ //哟，终于不用struct Node了，
    int data;
    Node * next;
} Node;
Node * visit_tail(iNode * head,int n,void (* func)(int cur)){ 
    //K&R 时代的函数指针，见到老佛爷啦！！Node *pfirst; 
    Node *psecond; //吓，终于用到匈牙利命名法了（老农：#!?%）
    pfirst=head;
    for(counter=0;counter<n;counter++){
        if(pfirst->next)
            pfirst=pfirst->next;
        else
            return NULL; //什么破编程风格，真实版初学者啊
    }

    psecond=head;
    while(pfirst!=NULL) {
        pfirst=pfirst->next;
        psecond=psecond->next;
    }
    for(int i=0;i < n; i++)
        (* func)(psecond.data);
        psecond=psecond->next;
    }
} //靠，一个函数解决所有问题，高耦合啊！

typedef T int
    //没有 C++ 一样“泛型”！

typedef struct {
    T data;
    Node * next;
} Node;

typedef struct {
    Node * pre;
    Node * curr; //当前结点与 List 绑定，不但可以分步例遍，还能保证正确初始化
} List;

void init_curr (List * l) {
    l->curr = l->pre; //什么叫“编程风格”，知道不？！
}

void visit (List *l, void (* func)(T data)) {
    while (l-curr) { //少用 !=NULL，这可是《The C Programing Language》上说的！
        (* func)(l-curr->data);
        l-curr = l->curr->next;
    }
} //使用内联结点的公用访问函数，降低耦合

void index (List * l, int n) {
    if (n) return NULL; //结点下标从1开始
    init_curr(l);
    if (n > 0) {
        for (int i = 0; i < n; i++) {
            curr = l->curr->next;
        }
    } //小四（自我陶醉）：漂亮啊
    if (n < 0) {
        tmp = l->curr;
        for (int i = 0; i < n; i++) {
            tmp = tmp->next;
        }
        while (tmp) {
            l->curr = l->curr->next;
            tmp = tmp->next;
        }
    }
    return l->curr; //方便用户，增强鲁棒性能
}

void visit_tail (List * l, int n, void (* func)(T data)) {
    index(l, -n);
    visit(l, func);
} //多清爽

package datastruct.fifi.com.baidu.hi; //加入我的数据结构Java包

//当然只有包内成员才能创建Node对象
protected class Node {
    private Object data; //多态性，让你们的 typedef 去死吧！
    private Node next;

    //构造函数
    Node (Object data) {
        this.data = data;
    }

    //获取下一个元素
    public Node next () {
        return this.next;
    }

    //变换下一个元素，用户不能调用
    protected void setNext (Node o) {
        this.next = o;
    }

    //取数据
    public Object getData () {
        return this.data;
    }

    //换数据
    public void setData (Object data) {
        this.data = data;
    }

    //根据Effective Java的最高指导，要重写toString()方法
    public String toString () {
        return this.data.toString();
    }
}

//自定义异常类，数据结构下标越界
public class IndexOutOfRangeException extend IndexOutOfBoundsException {
    public IndexOutOfRangeException (int lower, int upper, int index) {
        super("Lower: " + lower +", Upper: " + upper + ", index: " + index);
    }
}

//用于被继承的访问类
public class Visitor {
    public operation (Object o) { //访问操作
        System.out.println(o);
    }
}

public class List {
    private Node preFix;
    private Node current;
    private int size;

    List () {
        current = preFix = new Node();
        size = 0;
    }

    //定位函数
    private void index (int i) throws IndexOutOfRangeException {
        if (i > size || i < -size-1) {
            thows new IndexOutOfRangeException(0, size+1, i);
        }
        this.init();
        if (i >= 0) {
            for (int j=0; j < i; j++) {
                current = current.next();
            }
        }
        if (i < 0) {
            i = - i - 1;
            for (int j=0; j < i; j++) {
                current = current.next();
            }
        }
    }

    //基本访问函数,需要一个继承自Visitor类的访问工具
    public visit (Visitor v) {
        while (current != null) { //Java拒绝看不懂的 while(curr) ！
            v.operation (current.data());
            current = current.next();
        }
    }

    //访问后n个元素
    public visitTail (Visitor v, int n) {
        this.index(-n);
        this.visit(v);
    }
}

(define (list-visit-tail func n l)
    (map func (list-tail l (- (length l) n))))

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

function Light (light) {
	//填充对象属性
	this.light = light ? light : 0
	this.state = false
	
	//对象方法。
	//放心，JavaScript 没傻到给每个对象都真去分配一个函数的地步
	this.turnOn = function () {
		this.state = true
	}
}

new Light(100) instanceof Light
js> true

//访问属性
new Light(100).light
js> 100
anOnLight = new Light()
//调整属性
anOnLight.state = true

aLight = new (function (light){
	this.light = light ? light : 0
	this.state = false
)(90)

//类属性
Light.SIZE = 5
//类函数
Light.newInstence = function (arg) {
	//这么简单的 Factory 模式
	//this 指向函数运行所在名字空间的上级
	return new this(arg)
}

anOnLight.constructor.SIZE
js> 5

Light.prototype.turnOff = function () {
	this.state = false
}
anOnLight.turnOff()
anOnLight.state
js> false

function PhilipLight (price) {
	this.price = price
}
//事实上是建立了一个匿名的 Light 实例，然后将其能力反映给 PhilipLight
//飞利浦灯泡的亮度默认为100。这种继承模式很有意思。
PhilipLight.prototype = new Light(100)
myLight = new PhilipLight(12)
myLight.price
js> 12
//类方法照用。对象方法也照用。
myLight.turnOn()
myLight.state
js> true

//把那些垃圾的库抛在脑后，让它们见识见识什么叫优雅。
Object.prototype.extend = function (aClass) {
	this.prototype = new aClass
}
PhilipLight.extend(Light) //No problem

//Light 也是一种商品
function Product (price) {
	this.price = price
	//买 num 件商品需要的钱
}
Product.prototype.buySetOf = function (num) {
	return this.price * num
}
//那么对于同样有 price 属性的飞利浦灯泡，我们可以这样计算买10个灯泡要多少钱：
Product.prototype.buySetOf.call(myLight, 10)
js> 120
//apply 的第二个参数是被 call 的参数列表
Product.prototype.buySetOf.apply(myLight, [10])
js> 120

Object.prototype.mixin = function (aClass) {
	//这里用到的技术下文中讲解
	this.prototype.app = function (func, args) {
		//func 是消息字符串
		if (this[func] != undefined)
			return (this[func].apply(this, args))
		return (aClass.prototype[func].apply(this, args))
	}
}
PhilipLight.mixin(Product)
myLight = new PhilipLight(12)
myLight.app('buySetOf', [10])
js> 120

Object.prototype.able = function (anObject) {
	this.app = function (func, args) {
		//func 是消息字符串
		if (this[func] != undefined)
			return (this[func].apply(this, args))
		return (anObject[func].apply(this, args))
	}
}
//这个用法弱智了点，但确实能说明问题
myLight.able(new Product)
myLight.app('buySetOf', [10])
js> 120

function Desk (height) {
	//对于一个符合标准的实现，这里的 var 关键字可以省略
	var height = height ? height : 0
	var weight = 0
	//下面的东西对于 Java 程序员来说很熟悉 :)
	this.getHeight = function () {
		return height
	}
	this.setHeight = function (num) {
		height = num
	}
}
deak = new Desk(34)
deak.getHeight()
34
deak.setHeight(45)
deak.getHeight()
45
desk.height
ReferenceError line 1：desk.height is not defined

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师