计算机语言的主要功能：
- 基本操作符和操作单位(eg: number 和 加减法)
- 聚合的方法，把多个元素集合为一(eg: 1+1)
- 抽象的方法，让一个复杂的元素作为一个单元使用(eg: function)
函数调用方法：
- 正常序：先完全展开再计算
- 应用序：边计算边展开
例如：
(define (sqrt x) (* x x))
(+ (sqrt (sqrt 3)) (sqrt 4))
- 正常序：
(+ (* (* 3 3) (* 3 3)) (* 4 4)) => 97 - 应用序：
(+ (* 9 9) 16) => 97
迭代与递归：
一直有很多人认为递归就是函数调用自身。而实际上这里指的“递归”只是函数处理的形式，而并不是递归的处理形式。处理形式上迭代和递归的区别是，迭代保存了当前的运行状态，无需展开后再执行收缩，而递归是展开完全后再计算收缩。例如迭代即使中途停止，只要给它一个状态值就可以得到最终结果，而递归就不行，它没有显式保存状态值，必须从头开始运算。以调用自身的方式进行迭代的过程，我们称之为尾递归。
线性递归：
(define (factorical n)
(if (= n 1)
1
(+ n (factorical (- n 1)))))
树形递归：
斐波那契：
(define (fib n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fib (- n 1))
(fib (- n 2))))))
换零钱的方法数：
(define (count-change amount kinds-of-coins) (cc amout 5))
(define (cc amount kinds-of-coins)
(cond ((= amount 0) 1)
((or (< amount 0) (= kinds-of-coins 0)) 0)
(else (+ (cc amount (- kinds-of-coins 1))
(cc (- amount (value kinds-of-coins)) kinds-of-coins))))))
换零钱的方法数 = 不使用使用当前面额的方法数 + 使用当前面额的方法数
指数：
计算一个数的平方时一般用这个方法：
(define (exponent b n)
(cond ((= n 0) 1)
(else (* b (exponent b (- n 1))))))
这样计算的时间复杂度是 O(n)，但是我们有更好的方法。先判断指数为奇数还是偶数，当为偶数时调用 square，为奇数就 (* b (exponent b (- n 1)))，这样就可以减少接近一半的函数调用，时间复杂度为 O(log2 n)。
(define (fast-exponent b n)
(cond ((= n 0) 1)
((even? n) (square (fast-exponent b (/ n 2))))
(else (* b (fast-exponent b (- n 1))))))
(define (square x) (* x x))
高阶函数：
在 lisp 中，函数可作为一个参数传进另一个函数里面，这样的话我们就能实现一个更为抽象的函数（高阶函数）。
例如一个我们实现一个 sum 函数，让它进行从 a 到 b 的平方累加运算：
(define (sum f a next b)
(if (> a b)
0
(+ (f a) (sum f (next a) next b))))
(define (normal-sum a b)
(sum
(lambda (x) (* x x))
a
(lambda (x) (+ x 1))
b))
然后，我们发现其实可以总结为一个更高阶的函数 accumulate，进行任意地累次运算。
(define (accumulate combiner null-value f a next b)
(if (> a b)
value
(combiner (f a) (sum f (next a) next b))))
(define (sum f a next b)
(accumulate + 0 f a next b))
返回函数
函数可作为一个返回值，当我们返回一个函数时，这通常代表返回的函数派生自接受的函数。
(define (transform f) (lambda (y) (+ (f x) 1)))
(define num (transform (lambda (x) (* x x)) 4))
总结
sicp 的第一章主要讲一个函数是怎样从只适用于特定环节，到抽象成适用于类似的通用情况。这一章用了很多的数学公式，从牛顿迭代法到微积分，sicp 利用了牛顿迭代法是微分的特殊情况，构造了微分的方法，并从微分中派生出了牛顿迭代法，利用不定点根据牛顿迭代的函数进行搜索，可以说是抽象到了极致。我们在写自己的程序时可以适当考虑一下是否可以抽象，以及是否有必要抽象，要根据实际情况选择抽象的等级。
