标签：style http color os 使用 java ar strong for
高阶过程：以过程为参数和/或返回值的过程
lambda 表达式
let 表达式
用过程作为解决问题的通用方法
返回过程值
过程是语言里的一等公民 (first-class object)
过程是抽象，一个过程描述了一种对数据的复合操作,如求立方过程：(define (cube x) (* x x x))
换个方式，也可以总直接写组合式：(* 3 3 3), (* x x x), 不定义过程，总基于系统操作描述，不能提高描述的层次,
虽然也能计算立方，但程序里没建立立方的概念, 将常用公共计算模式定义为过程并命名，就是在程序里建立概念.
过程抽象起着建立新概念的作用。基于定义好的过程编程，就是基于更高级的新概念思考问题，非常重要.
不过上面定义的过程(define (cube x) (* x x x))只能以数值作为参数也限制了建立抽象的能力。例如在一些计算模式里，在某个（某些）地方可以使用不同的过程要建立这类计算模式的抽象，就需要以过程作为参数或返回值
高阶过程：以过程作为参数或返回值，操作过程的过程
但这些功能的能力都比较有限, Java、C# 等引进 lambda 表达式，是为了在这方面有所前进
需要高阶过程的一类情况
下面引入高阶抽象
虽然细节有许多差异，但它们有共同的模式：从某参数 a 到参数 b，按一定步长，对依赖于 a 的一些项求和. 把其中的公共模式较严格地写出来（标明变化的部分）：
(define (<pname>ab) (if (> a b) 0 (+ (<term>a) (<pname>(<next> a) b))))
一些过程有公共的模式，说明可能存在一个有用的抽象。如果编程语言的功能足够强，就有可能利用和实现这种抽象
Scheme 允许以过程为参数，上面抽象的实现很直接：
(define (sum term a next b) (if (> a b) 0 (+ (term a) (sum term (next a) next b))))参数 term 和 next 是计算一个项和计算下一a值的过程.
上面的求和几个函数都能基于 sum 定义（只需提供具体的 term 和 next）
(define (inc n) (+ n 1)) // 求a到b的立方和 (define (cube n) (* n n n )) (define (sum-cubes a b) (sum cube a inc b)) (define (identity x) x) // 求a到b的累加和 (define (sum-integers a b) (sum identity a inc b)) (define (pi-sum a b) // pi-sum (define (pi-term x) (/ 1.0 (* x (+ x 2)))) (define (pi-next x) (+ x 4)) (sum pi-term a pi-next b) )
如果某个抽象真有用，那么一定能用它形式化很多概念。例如，可以用sum 实现数值积分，公式是
其中 dx 是很小的步长值
我们可以将这一过程直接定义如下:
(define (integral f a b dx)
(define (add-dx x)(+ x dx))
(* (sum f (+ a (/ dx 2.0)) add-dx b)dx))
结果如下
C 语言里不允许把函数为参数，但允许函数指针参数,由于有类型，函数指针参数也要声明指针的类型..具体参考C语言的相关资料.
前面用 sum 时都为 term 和 next 定义了专门过程。如
(define (pi-sum a b) // pi-sum
(define (pi-term x) (/ 1.0 (* x (+ x 2))))
(define (pi-next x) (+ x 4))
(sum pi-term a pi-next b) )
这些过程只用一次，为它们命名没有实际的价值,最好是能表达”那个返回其输入值加 4 的过程”等概念，而不专门定义pi-next 等命名过程.
这实际上是一个数学问题： f(x) = sin x + x, 说了两件事：描述了一个函数，并给它取了名字, 实际上，定义函数和给它命名是两件事, 应该作为两件事，分开做，考虑如何说一个函数但不命名.由此便引出对lambda的构造过程
从上面的一段关于名字的讨论中,可以看出我们需要一种可以匿名命名过程的技术,而Scheme 恰好可以通过 lambda 特殊形式处理这个问题，求值”lambda表达式”得到一个匿名过程.
lambda 表达式把一段计算参数化，抽象为一个（匿名）过程
比如，下面几个表达式都计算距离，有共同的计算模式
<span style="font-size:12px;">(sqrt (+ (* 5 5) (* 8 8))) (sqrt (+ (* 11 11) (* 17 17))) (sqrt (+ (* 128 128) (* 213 213)))</span>可以考虑其共性的抽象，建立相应的过程对象, 描述相应过程对象的lambda表达式：
(lambda (x y) (sqrt (+ (* x x) (* y y))))求值这个表达式，得到”求距离的过程对象”.
利用 lambda 表达式重新定义 pi-sum：
(define (pi-sum a b) (sum (lambda (x) (/ 1.0 (* x (+ x 2)))) a (lambda (x) (+ x 4)) b))两个 lambda 表达式:(lambda (x) (/ 1.0 (* x (+ x 2)))) ,带有一个参数 x 的 lambda 表达式, 表达式的体是 (/ 1.0 (* x (+ x 2))), 以及(lambda (x) (+ x 4)),带有一个参数 x 的 lambda 表达式, 表达式的体是 (+ x 4).
用同样技术定义积分函数 integral，也不再定义局部函数：
<span style="font-size:12px;">(define (integral f a b dx) (* (sum f ; sum term (+ a (/ dx 2.0)) ; a (lambda (x) (+ x dx)) ; next b) ; b dx)) </span>lambda 表达式的思想源自数学家 A. Church 提出的 λ-演算. Church 当时也在研究计算的抽象表述问题, 他在 1940 年代提出了 λ-演算，其工作的精髓是提出了一套数学记法和规则，表示函数的描述与函数应用, 已证明，λ-演算是与图灵机等价的计算模型, λ-演算可以看作抽象的编程语言，它是编程语言理论研究的一个重要基础和工具，在计算机科学领域具有重要地位.
可以看出, Scheme 里 lambda 表达式的一般形式：
(lambda (<formal-parameters>) <body> )
形式上与 define 类似，有形式参数表和体（但没有过程名）, lambda 是特殊形式，其参数不求值
实际上，用 define 定义过程只是一种简写形式，下面两种写法等价：
(define(plus4x)(+x4)) ; 定义一个过程并用 plus4 命名 (define plus4 (lambda (x) (+ x 4))) ;给 plus4 关联一个过程对象 ;一般说： (define (<name> <formals>) <body>) ;相当于 (define <name> (lambda (<formals>) <body>))Scheme 允许前一写法只是为了易用，没有任何功能扩充.
求值 lambda 表达式建立一个新过程, 建立的过程可以用在任何需要用过程的地方, 在 Scheme 语言里，过程也是对象.就像整数、字符串等，都是对象, 程序运行中可以建立各种对象, 求值 lambda 表达式是建立过程对象的唯一方式
由于 lambda 表达式的值是过程，因此可以作为组合式的运算符：
((lambda (x y z) (+ x y (square z))) 1 2 3)
12
第一个子表达式求值得到一个过程, 得到的过程应用到其他参数的值（组合式的求值规则）.
前面几个例子用 lambda 表达式作为过程的参数
这样直接使用 lambda 表达式，主要作用是
这些还没表现出 lambda 表达式的本质价值
C 等常规语言没有 lambda 表达式,但至今为止的情况都可以用命名函数模拟.
设要定义一个复杂函数，例如：
如果直接定义，有些子表达式需要多次计算
一种技术是引进临时变量保存中间信息：
程序中常出现这类情况,需要引进辅助变量记录一段程序计算出的中间值,而在Scheme 里的一种解决方法：定义一个内部辅助函数
#lang planet neil/sicp (define (f x y) (define (square n) (* n n)) (define (f-helper a b) (+ (* x (square a)) (* y b) (* a b))) (f-helper (+ 1 (* x y)) (- 1 y))) (f 2 3)
这里的技术是：
当然前面辅助函数可以用一个 lambda 表达式代替。定义：
#lang planet neil/sicp (define (f x y) (define (square x) (* x x)) ( (lambda (a b) (+ (* x (square a)) (* y b) (* a b))) (+ 1 (* x y)) (- 1 y)))结果:
为lambda 表达式引进两个参数，以公共表达式作为应用的对象
技术:
但是这种写法不太清晰（lambda 表达式较长，与参数的关系不易看清.因此便引入了let表达式机制.
程序中经常需要这种结构，Scheme 引进 let 结构（是上述 lambda 表达式的变形）用于引进辅助变量，传递中间结果.
过程 f 可重新定义为：
let 引进了两个局部变量并分别约束值，let 体用这些变量完成计算
比较：
let 表达式的一般形式：前面是一组变量/值表达式对，表示建立约束关系
(let ((<var1><exp1>)
……
( <varn> <expn> ) )
<body>)读作：令 <var1> 具有值 <exp1>，且 <var2> 具有值 <exp2> ……且<varn> 具有值 <expn> 做 <body>
let是 lambda 表达式的一种应用形式加上语法外衣，等价于：
((lambda ( <var1> …<varn> )
<body>)
<exp1>
……
<expn>)在let 结构里，为局部变量提供值的表达式在let之外计算，其中只能引用本 let 之外的变量.简单情况里看不出这种规定的意义, 如果出现局部变量与外层变量重名，就会看到这一规定的意义
例如：
(let ((x 3) (y (+ x 2))) (* x y))let头部的变量约束中把y约束到由外面的x求出的值,不是约束到这个 let 里面的 x 的值, 如果外面的 x 约束值是 5，表达式的值将是 21
高阶过程的功能:
下面讨论两个更有趣的高阶函数实例，研究两个通用问题的解决方法：
基于这两个方法定义的抽象过程可用于解决许多具体问题.
问题：找区间里方程的根：区间 [a, b]，若 f(a) < 0 < f(b)，[a, b] 中必有 f 零点（中值定理）
折半法：取区间中点 x 计算 f(x)
易见，上面操作做一次，区间长度减半假设初始区间的长度为 L，容许误差为 T,所需计算步数为 O(log(L/T)).是对数时间算法.而且不难定义一个 Scheme 过程实现这个算法.
实现折折半法求零点的过程:
(define (search f neg-point pos-point) (let ((midpoint (average neg-point pos-point))) (if (close-enough? neg-point pos-point) midpoint (let ((test-value (f midpoint))) (cond ((positive? test-value) (search f neg-point midpoint)) ((negative? test-value) (search f midpoint pos-point)) (else midpoint))))))
编程原则：
需要一个子过程判断区间足够小（谓词）：评价标准可根据需要确定
(define (close-enough? x y)
(< (abs (- x y)) 0.001))
把判断区间满足要求的方法抽象为过程，另行定义，优点：
用户提供的区间可能不满足 search 的要求（两端点函数值异号）。可以定义一个包装过程，只在参数合法时调用 search：
<span style="font-size:12px;">(define (half-interval-method f a b) (let ((a-value (f a)) (b-value (f b)) ) (cond ((and (negative? a-value) (positive? b-value)) (search f a b)) ((and (negative? b-value) (positive? a-value)) (search f b a)) (else (error “Values are not of opposite sign” a b)) ) ))</span>error 是发错误信号的内部过程，它逐个打印各参数（任意多个）
使用（实例）：求 pi 的值（sin x 在 2 和 4 之间的零点）：
用折半法求一个函数的根
很多问题可以归结到求函数 0 点（求函数的根）,数值计算情况，都可以用 half-interval-method, 函数可以事先定义，也可以直接用 lambda 描述.
定义：x 是函数 f 的不动点，如果将 f 作用于 x 得到的还是 x. f的不动点就是满足等式f(x) = x的那些 x.
显然，并非每个函数都有不动点。反例很多，如(lambda (x) (+ x 1)).
存在一些有不动点的函数，从某些初值出发，反复应用这个函数，可以逼近它的一个不动点, 即使有不动点，也未必满足具有这种性质, 可能与初值选择有关。有这样的函数，从一些初值出发可以达到不动点，从另一些初值出发达不到不动点
下面只考虑有不动点的函数，而且假设知道合适的初值。在这种情况下考虑不动点的计算问题
有些函数存在不动点，但简单地反复应用上述函数却不能达到不动点.
x 的平方根可看作 f(y) = x/y的不动点
考虑用下面求平方根过程：
(define (sqrt x)
(fixed-point (lambda (y) (/ x y)) 1.0 ))
它一般不终止（产生的函数值序列不收敛），因为：
控制振荡的一种方法是消减变化的剧烈程度。因为问题的答案必定在两值之间，可考虑用它们的平均值作为下一猜测值：
(define (sqrt x)
(fixed-point (lambda (y) (average y (/ x y)))
1.0) )
试验说明，现在计算收敛，能达到不动点（得到平方根）
上面减少振荡的方法称为平均阻尼技术.
(lambda (y) (average y (/ x y))) 是
(lambda (y) (/ x y)) 的派生函数，可称为
(lambda (y) (/ x y)) 的平均阻尼函数.
从函数构造其平均阻尼函数的操作很有用，构造方法具有统一模式，能不能定义过程完成这一构造？
在 Scheme 里函数用过程表示，上面工作要求定义一个高阶过程，它需要在执行中创建并返回一个新过程，这是个新问题.这应该是有用的程序技术，因为增强了表述计算进程的能力.
在 Scheme 里很容易构造新的过程对象并将其返回,只需用 lambda 表达式描述过程的返回值。
最简单的模式： (define (g f …) (lambda (…) …) )
下面过程计算出与 f 对应的平均阻尼过程：
(lambda (x) (average x (f x))))
注意：average-damp以过程 f 为参数，返回基于 f 构造的另一过程，实现的是一种从过程到过程的变换对任何函数实参，它都能返回这个实参函数的平均阻尼函数
在计算中生成新过程（对象）是前面没遇到过的新问题，实际上这是lambda 表达式最重要的作用, 常规语言（Java/C++/C#）引入 lambda 表达式的目的也在于此.
把 (average-damp f) 构造的过程作用于 x，平方根函数可以重新定义
注意新定义的特点：基于两个通用过程，它们分别求不动点和生成平均阻尼函数,两个通用过程都可以用于任意函数,具体函数用 lambda 表达式直接构造
许多问题可以归结为求不动点.
下面用牛顿法求根作为返回 lambda 表达式的另一应用,一般牛顿法求根牵涉到求导,设要求 g 的根, 牛顿法说 g(x) = 0 的解是下面函数的不动点
要用这个公式，需要能求出给定函数 g 的导函数,求导是从一个函数（原函数）算出另一函数（导函数）。在 Scheme 里实现，就是构造新过程.可以在 Scheme 做符号求导,现在考虑一种”数值导函数“，g(x) 的数值导函数是D g(x) = (g(x + dx) – g(x)) / dx
做数值计算，可以用一个很小的数值作为 dx，如 0.00001.
把 dx 定义为全局变量（也可以作为参数）：( define dx 0.00001)
生成”导函数”的过程定义为：
(define(derivg)
(lambda (x)
(/ (- (g (+ x dx)) (g x))
dx) ) )
生成的过程是 g 的数值导函数, 用 deriv 可以对任何函数求数值导函数,如例：
可以把牛顿法定义为一个求不动点的函数：
;牛顿法 过程抽象过程
(define (newton-transform g)
(lambda (x) (- x (/ (g x) ((deriv g) x)))))
; 过程抽象
(define (newtons-method g guess)
(fixed-point (newton-transform g) guess))
newton-transform 从函数 g 构造出另一个Scheme 过程，它能计算g 的导函数的近似值。这也是构造新过程.这个牛顿法求根函数可以用于任何函数
求导函数的操作是数值计算，得到原函数的数值导函数。对同样dx 不同函数的误差不同。不同 dx 也可能导致不同的计算误差
Scheme 的优势是符号计算，操作各种符号形式的表达式, 可以用符号表达式表示代数表达式。在 Scheme 里很容易实现符号求导.
基于 newton-method 也可以计算平方根, x 的平方根可以看作函数 (lambda (y) (- (* y y) x)) 的 0 点, 基于这一观点定义的求平方根过程
从初始值 1.0 出发求函数的不动点, 类似的，x 的立方根是函数 (lambda (y) (- (* y y y) x)) 的 0 点, 同样可以基于这一观点求 x 的立方根
上面用两种不同方法求平方根，都是把平方根表示为另一种更一般的计算方法的实例：
这两种方法有共同模式，可以进一步推广为一个通用过程(
define (fixed-point-of-transform g transform guess)
(fixed-point (transform g) guess))
上面过程的意义是基于一个实现某种变换的过程 transform, 求某个函数 g 经某种变换得到的函数的从一个猜测出发的不动点, 只要一个计算可以表达为这种模式，都可以基于这个高阶过程描述, 只需提供适当的实现变换的 transform.
基于前面高阶过程，可以写出平方根函数的另外两个定义：
在编程中，要注意发现和总结遇到的有用抽象，正确识别并根据需要加以推广，以便用于更大范围和更多情况.
语言对各种计算元素的使用可能有限制。如：
使用限制最少的元素称为语言中的”一等”元素，是语言的”一等公民”，具有最高特权（最普遍的可用性）。常见的包括：
在 Scheme（及其他 Lisp 方言）里，过程具有完全一等地位。这给语言实现带来一些困难，也为编程提供了极大潜力。后面有更多的讨论
标签：style http color os 使用 java ar strong for
原文地址：http://blog.csdn.net/suool/article/details/39271241
