本文永久链接 – https://tonybai.com/2024/08/11/understand-functional-programming-in-go

一个孩子要尝试10次、20次才肯接受一种新的食物，我们接受一种新的范式，大概不会比这个简单。– 郭晓刚 《函数式编程思维》译者

函数式编程(Functional Programming, 简称fp)是一种编程范式，与命令式编程(Imperative Programming)、面向对象编程(OOP)、泛型编程(Generics Programming)、逻辑编程(logic Programming)等是一类的概念。

注：尽管面向对象范式引入了新的编程思想和技术，但它本质上与命令式编程一样，都关注程序的状态和如何通过改变状态来控制程序的执行流程，因此，OOP仍然属于命令式编程的一个分支。OOP可以看作是命令式编程的一种扩展和补充，它增强了代码的模块化、复用性和可维护性。在接下来，我会统一使用命令式编程范式来指代它们。

但几十年的编程语言的演进和实践已经证明：函数式编程并非银弹，它有优势，更有不足。从编程社区的实际反映来看，纯函数式编程语言(比如：CLisp、Haskell、Scala、Clojure、Erlang等)始终处于小众地位。此外，即便很多主流命令式编程语言在近些年融入了一些函数式编程的语法特性，采用函数式风格的代码依旧比例极低，且不易被广泛接受。许多程序员在面对复杂的状态管理和副作用时，依然倾向于使用传统的命令式编程风格（包括OOP)。。

注：Go就原生提供了一些支持函数式范式编程的语法特性，比如：函数是一等公民(first-class)、高阶函数、闭包、函数迭代器以及泛型等。

造成这种局面的原因众说纷纭，但我认为有如下几个：

首先从人类这个物种的大脑的认知和思维方式来看，命令式编程更接近于人类的自然思维方式，其逻辑与人类解决问题时的逻辑思维相似，即都是以步骤的形式理解问题，且有明确的控制流：命令式语言的控制结构（如条件语句、选择语句和循环）使得程序的执行路径清晰可见，符合人类的直觉理解，这也使得命令式语言更容易被人类大脑所掌握。

其次，命令式编程强调状态的变化，程序员可以直接看到和控制变量的变化，这与人类处理现实世界事物的方式相似。

在上面原因的驱使下，久而久之，程序员便形成习惯与传统，有了积淀，便可以促进命令式编程语言在教育和产业中的广泛应用，使得大多数程序员习惯于这种编程方式（间接挤压了函数式编程的使用空间）。进而使得命令式语言有更丰富的学习资源和社区支持，程序员也更容易找到帮助和示例。

也就是说，命令式编程范式占据主流的根本原因是人类的大脑本身就是命令式的，而不是函数式的。不过也有极少数大脑是函数式思维的，比如发明了TLA+这门形式化建模和验证语言的Leslie Lamport老先生。

那么问题来了！既然学习函数式编程思维是违反人类大脑直觉的，且较为困难，那为什么还是有很多人学习函数式编程思维，并在实际开发中应用函数式编程范式呢？关于这个问题，我们可以从两方面来看。

从主观上说，程序员经常有探索新技术和新范式的内在动力，这种好奇心驱使他们尝试函数式编程，也就是我们俗称的“玩腻了，尝尝鲜儿”。并且，许多程序员视学习函数式编程为一种智力挑战，一种来自舒适区之外的挑战，这种挑战能带来成就感和个人成长。此外，在竞争激烈的IT行业，掌握多种编程范式可以使得个人技能多样化，增加个人的职业竞争力。

从客观上看，函数式编程也确实能帮助程序员提高抽象思维和系统设计能力，这种能力的提升不仅限于函数式编程，还能应用到其他编程范式中。并且，函数式编程为程序员提供了一个新的解决问题的视角和方法，特别是在处理并发和并行计算、复杂数据转换和流处理方面。

学习函数式编程范式，并不是说抛弃命令式范式(或其他范式)，而是融合，从主流编程语言对函数式编程的语法特性的支持也可窥见这般。

那么，到底什么是函数式编程范式？它与命令式范式对比又有怎么样的差异与优劣呢？在这篇文章中，我就来说说我的体会，并辅以Go示例来帮助大家理解。

1. 思维差异：命令式编程 vs. 函数式编程

在看过很多函数式编程的资料后（见文后的参考资料一节），我问了自己一个问题：面对同一个实际的问题，用命令式编程范式和用函数式编程范式的核心思维差异在哪里？为此，我基于现实世界的一个典型问题模型(数据输入 -> 数据处理 -> 处理结果输出)，并根据自己的理解画了下面两幅图：

我们先来描述一下上面两幅图中的数据处理流程：

• 命令式编程：通过I/O操作获取数据，然后解码为自定义类型进行处理，再编码为自定义类型以便I/O操作输出。处理过程中使用函数、带方法的类型和控制流结构（如for、if、switch等）。

• 函数式编程：通过带有副作用的操作（如I/O操作）获取数据，然后解码数据放入通用数据结构（如列表、元组、映射）进行处理，再放入通用数据结构以便通过副作用操作输出。处理过程中会使用纯函数、高阶函数以及它们的函数组合。

基于上述流程的说明，我们可以看出两种范式核心关注点的差异：

• 命令式编程范式：更关注类型的封装、类型间的耦合关系、行为集合的抽象(接口)以及对数据在类型实例间的传递的显式控制(if/for/switch)。
• 函数式编程范式：弱化类型的概念，使用通用数据结构，专注于通过纯函数/高阶函数、不可变数据和函数组合来实现对数据的处理逻辑。“控制流”更加隐含，比如会通过递归、模式匹配和惰性求值等方式实现。建立专门的抽象来应对与真实世界交互时的带有副作用(side effect)的操作。

下面我们通过一个具体的问题来大致体会一下不同编程泛型在解决问题的实现上的思维差异。这个问题很简单：编写一个程序从input.txt文件中读取数字(每行一个数字)，将每个数字乘以2，然后将结果写入output.txt文件中。

我们先来用命令式编程范式实现：

// fp-in-go/double/go/main.go

// NumberData represents the input data
type NumberData struct {
    numbers []int
}

// ProcessedData represents the processed output data
type ProcessedData struct {
    numbers []int
}

// NewNumberData creates and returns a new NumberData instance
func NewNumberData() *NumberData {
    return &NumberData{numbers: []int{}}
}

// AddNumber adds a number to NumberData
func (nd *NumberData) AddNumber(num int) {
    nd.numbers = append(nd.numbers, num)
}

// Process doubles all numbers in NumberData and returns ProcessedData
func (nd *NumberData) Process() ProcessedData {
    processed := ProcessedData{numbers: make([]int, len(nd.numbers))}
    for i, num := range nd.numbers {
        processed.numbers[i] = num * 2
    }
    return processed
}

// FileProcessor handles file operations and data processing
type FileProcessor struct {
    inputFile  string
    outputFile string
}

// NewFileProcessor creates and returns a new FileProcessor instance
func NewFileProcessor(input, output string) *FileProcessor {
    return &FileProcessor{
        inputFile:  input,
        outputFile: output,
    }
}

// ReadAndDeserialize reads data from input file and deserializes it into NumberData
func (fp *FileProcessor) ReadAndDeserialize() (*NumberData, error) {
    file, err := os.Open(fp.inputFile)
    if err != nil {
        return nil, fmt.Errorf("error opening input file: %w", err)
    }
    defer file.Close()

    data := NewNumberData()
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        num, err := strconv.Atoi(scanner.Text())
        if err != nil {
            return nil, fmt.Errorf("error converting to number: %w", err)
        }
        data.AddNumber(num)
    }

    if err := scanner.Err(); err != nil {
        return nil, fmt.Errorf("error reading input file: %w", err)
    }

    return data, nil
}

// SerializeAndWrite serializes ProcessedData and writes it to output file
func (fp *FileProcessor) SerializeAndWrite(data ProcessedData) error {
    file, err := os.Create(fp.outputFile)
    if err != nil {
        return fmt.Errorf("error creating output file: %w", err)
    }
    defer file.Close()

    writer := bufio.NewWriter(file)
    defer writer.Flush()

    for _, num := range data.numbers {
        _, err := writer.WriteString(fmt.Sprintf("%d\n", num))
        if err != nil {
            return fmt.Errorf("error writing to output file: %w", err)
        }
    }

    return nil
}

// Process orchestrates the entire data processing workflow
func (fp *FileProcessor) Process() error {
    // Read and deserialize input data
    inputData, err := fp.ReadAndDeserialize()
    if err != nil {
        return err
    }

    // Process data
    processedData := inputData.Process()

    // Serialize and write output data
    err = fp.SerializeAndWrite(processedData)
    if err != nil {
        return err
    }

    return nil
}

func main() {
    processor := NewFileProcessor("input.txt", "output.txt")
    if err := processor.Process(); err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("Processing completed successfully.")
}

这段代码十分容易理解，在这段代码中，我们建立了三个类型：NumberData、ProcessedData和FileProcessor。前两个分别代表解码后的输入数据和编码前的输出数据，FileProcessor则是封装了文件操作和数据处理的逻辑的自定义类型。这段代码将文件I/O、数据处理和主要流程控制分离到不同的方法中。在读取和写入过程中，数据经历了字符串 -> NumberData -> ProcessedData -> 字符串的转换过程，同时数据也是在不同类型的方法间传递和变换状态。

接下来我们再来看看函数式范式版本，Go虽然提供了一些函数式编程的基础支持，比如一等公民的函数、支持高阶函数、闭包等，但一些像monad、monoid等高级概念还需要手工实现。IBM开源了一个Go的函数式编程基础库fp-go，这里就借用fp-go的便利实现上面的同等功能，我们看看风格上有何不同：

// fp-in-go/double/fp-go/main.go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"

    "github.com/IBM/fp-go/either"
    "github.com/IBM/fp-go/ioeither"
)

// 读取文件内容
func readFile(filename string) ioeither.IOEither[error, string] {
    return ioeither.TryCatchError(func() (string, error) {
        content, err := os.ReadFile(filename)
        return string(content), err
    })
}

// 将字符串转换为数字列表
func parseNumbers(content string) either.Either[error, []int] {
    numbers := []int{}
    scanner := bufio.NewScanner(strings.NewReader(content))
    for scanner.Scan() {
        num, err := strconv.Atoi(scanner.Text())
        if err != nil {
            return either.Left[[]int](err)
        }
        numbers = append(numbers, num)
    }
    return either.Right[error](numbers)
}

// 将数字乘以2
func multiplyBy2(numbers []int) []int {
    result := make([]int, len(numbers))
    for i, num := range numbers {
        result[i] = num * 2
    }
    return result
}

// 将结果写入文件
func writeFile(filename string, content string) ioeither.IOEither[error, string] {
    return ioeither.TryCatchError(func() (string, error) {
        return "", os.WriteFile(filename, []byte(content), 0644)
    })
}

func main() {
    program := ioeither.Chain(func(content string) ioeither.IOEither[error, string] {
        return ioeither.FromEither(
            either.Chain(func(numbers []int) either.Either[error, string] {
                multiplied := multiplyBy2(numbers)
                result := []string{}
                for _, num := range multiplied {
                    result = append(result, strconv.Itoa(num))
                }
                return either.Of[error](strings.Join(result, "\n"))
            })(parseNumbers(content)),
        )
    })(readFile("input.txt"))

    program = ioeither.Chain(func(content string) ioeither.IOEither[error, string] {
        return writeFile("output.txt", content)
    })(program)

    result := program()
    err := either.ToError(result)

    if err != nil {
        fmt.Println("Program failed:", err)
    } else {
        fmt.Println("Program completed successfully")
    }
}

相对于前面使用命令式范式风格的代码，这段函数式范式的代码理解起来就要难上不少。

不过，这段代码很好地诠释了函数式编程中的函数组合理念，我们看到函数被当作值来传递和使用。例如，在ioeither.Chain中，我们传递了匿名函数作为参数，这体现了函数式编程中函数作为一等公民的概念。multiplyBy2函数是一个纯函数的例子，它没有副作用，对于相同的输入总是产生相同的输出。这种纯函数更容易测试和推理。

代码中最明显的函数组合例子是在main函数中，我们使用ioeither.Chain来组合多个函数操作。并且在这里，我们将文件读取、内容处理和文件写入操作串联在一起，形成一个更大的操作。而ioeither.Chain和either.Chain又都是高阶函数的例子，它们接受其他函数作为参数并返回新的函数。Either和IOEither类型也是函数式编程中用于错误处理的主流方式，允许我们以更函数式的方式处理错误，将错误处理集成到函数组合中。

很多人好奇如果用纯函数式编程语言实现这个示例会是什么样子的，下面我就贴一段Haskell语言的代码，大家简单了解一下，这里就不对代码进行解释了：

// fp-in-go/double/fp-haskell/Main.hs

import System.IO
import Control.Monad (when)
import Text.Read (readMaybe)
import Data.Maybe (catMaybes)

-- Define a custom type for the result
data DoubledNumbers = DoubledNumbers { doubledNumbers :: [Int] } deriving (Show)

-- Function to read numbers from a file
readNumbers :: FilePath -> IO (Either String [Int])
readNumbers filePath = do
    content <- readFile filePath
    let numbers = catMaybes (map readMaybe (lines content))
    return $ if null numbers
             then Left "No valid numbers found."
             else Right numbers

-- Function to write result to a file
writeResult :: FilePath -> DoubledNumbers -> IO (Either String ())
writeResult filePath result = do
    let resultString = unlines (map show (doubledNumbers result))
    writeFile filePath resultString
    return $ Right ()

-- Function to double the numbers
doubleNumbers :: [Int] -> DoubledNumbers
doubleNumbers numbers = DoubledNumbers { doubledNumbers = map (* 2) numbers }

main :: IO ()
main = do
    -- Read numbers from input.txt
    readResult <- readNumbers "input.txt"
    case readResult of
        Left err -> putStrLn $ "Error: " ++ err
        Right numbers -> do
            let result = doubleNumbers numbers
            -- Write result to output.txt
            writeResultResult <- writeResult "output.txt" result
            case writeResultResult of
                Left err -> putStrLn $ "Error: " ++ err
                Right () -> putStrLn "Successfully written the result to output.txt."

注：安装ghc后，执行ghc –make Main就可以将上面Main.hs编译为一个可执行程序。更多关于haskell编译器的信息可以到haskell官网查看。

从上面的示例我们大致也能感受到两种范式在思维层面的差异，正如Robert Martin在《函数式设计》一书中说道的那样：函数式程序更倾向于铺设调节数据流转换的管道结构，而可变的命令式程序更倾向于迭代地处理一个个类型对象。

我们很难在一个例子中体现出函数式编程的所有概念和思维特点，接下来，我们就来逐个说说函数式编程范式中的要素，你也可以对应前面的图中的内容，反复感受函数式编程的思维特点。

2. 函数式编程的要素

面向对象的编程通过封装不确定因素来使代码能被人理解，而函数式编程通过尽量减少不确定因素来使代码能被人理解。—— Michael Feathers 《修改代码的艺术》一书作者

函数式编程建立在几个核心要素之上，这些要素共同构成了函数式编程的基础。让我们逐一探讨这些要素。

2.1 纯函数 (Pure Functions)

纯函数是函数式编程的基石。一个纯函数具有以下特性:

• 对于相同的输入，总是产生相同的输出；
• 不会产生副作用(不会修改外部状态)；
• 不依赖外部状态。

例如，前面fp-go示例中的multiplyBy2就是一个纯函数:

func multiplyBy2(numbers []int) []int {
    result := make([]int, len(numbers))
    for i, num := range numbers {
        result[i] = num * 2
    }
    return result
}

这个函数总是为相同的输入返回相同的结果，并且不会修改任何外部状态。

2.2 不可变性 (Immutability)

Robert Martin在《函数式设计》一书为函数式编程下一个理想的定义：没有赋值语句的编程。实质是其强调了不可变性在函数式编程范式中的重要意义。在没有赋值语句的情况下，代码通常基于对原状态的计算而得到新的状态，而对原状态没有任何修改。

在Go语言中，由于不支持不可变变量(很多语言用val关键字来声明不可变变量，但Go并不支持)，我们通常通过复制对象来实现不可变性，这可以帮助我们避免状态变化带来的复杂性，但也因为复制而增加了内存开销和性能成本。

// 定义一个不可变的结构体
type Point struct {
    x, y int
}

// 创建一个新的 Point，模拟不可变性
func NewPoint(x, y int) Point {
    return Point{x, y}
}

// 移动Point的方法，返回一个新的Point
func (p Point) Move(dx, dy int) Point {
    return NewPoint(p.x+dx, p.y+dy)
}

2.3 高阶函数 (Higher-Order Functions)与函数组合(Function Composition)

Go语言的一个内置特性让它具备了使用函数式编程范式的前提，那就是在Go中，函数是一等公民。这意味着函数可以像其他类型变量一样，被赋值、传参和返回。

而接受其他函数作为参数或返回函数的函数，被称为高阶函数，这也是函数式编程的基石，如下面的applyOperation函数就是一个高阶函数：

func applyOperation(x int, operation func(int) int) int {
    return operation(x)
}

func double(x int) int {
    return x * 2
}

result := applyOperation(5, double) // 结果为10

而有了对高阶函数的支持，我们才能运用函数式思维中的核心思维：函数组合，来铺设调节数据流转换的管道结构：

// fp-in-go/high-order-func/main.go

package main

import (
    "fmt"
)

// 定义一个类型为函数的别名
type IntTransformer func(int) int

// 将多个转换函数组合成一个管道
func pipe(value int, transformers ...IntTransformer) int {
    for _, transformer := range transformers {
        value = transformer(value)
    }
    return value
}

// 定义一些转换函数
func addOne(x int) int {
    return x + 1
}

func square(x int) int {
    return x * x
}

func main() {
    // 使用管道处理数据
    result := pipe(3, addOne, square)
    fmt.Println("Result:", result) // 输出 Result: 16
}

这个示例中的pipe函数接受一个初始值和多个转换函数，并将其串联执行。main函数调用pipe函数，将addOne和square两个转换函数连接起来并执行输出结果。

前面那个使用fp-go编写的示例中，使用ioeither.Chain构建的program也是一个函数调用组合。

此外，链式调用也是一种在日常开发中常见的函数组合的使用形式，它融合了命令式的类型和函数式编程的函数组合，特别适用于集合类型数据的处理，通过链式调用，可以以更简洁和直观的方式进行数据转换和处理。下面是一个基于泛型实现的通用的链式调用(filter -> map -> reduce)的示例：

// fp-in-go/func-composition/main.go

package main

import "fmt"

// Collection 接口定义了通用的集合操作
type Collection[T any] interface {
    Filter(predicate func(T) bool) Collection[T]
    Map(transform func(T) T) Collection[T]
    Reduce(initialValue T, reducer func(T, T) T) T
}

// SliceCollection 是基于切片的集合实现
type SliceCollection[T any] struct {
    data []T
}

// NewSliceCollection 创建一个新的 SliceCollection
func NewSliceCollection[T any](data []T) *SliceCollection[T] {
    return &SliceCollection[T]{data: data}
}

// Filter 实现了 Collection 接口的 Filter 方法
func (sc *SliceCollection[T]) Filter(predicate func(T) bool) Collection[T] {
    result := make([]T, 0)
    for _, item := range sc.data {
        if predicate(item) {
            result = append(result, item)
        }
    }
    return &SliceCollection[T]{data: result}
}

// Map 实现了 Collection 接口的 Map 方法
func (sc *SliceCollection[T]) Map(transform func(T) T) Collection[T] {
    result := make([]T, len(sc.data))
    for i, item := range sc.data {
        result[i] = transform(item)
    }
    return &SliceCollection[T]{data: result}
}

// Reduce 实现了 Collection 接口的 Reduce 方法
func (sc *SliceCollection[T]) Reduce(initialValue T, reducer func(T, T) T) T {
    result := initialValue
    for _, item := range sc.data {
        result = reducer(result, item)
    }
    return result
}

// SetCollection 是基于 map 的集合实现
type SetCollection[T comparable] struct {
    data map[T]struct{}
}

// NewSetCollection 创建一个新的 SetCollection
func NewSetCollection[T comparable]() *SetCollection[T] {
    return &SetCollection[T]{data: make(map[T]struct{})}
}

// Add 向 SetCollection 添加元素
func (sc *SetCollection[T]) Add(item T) {
    sc.data[item] = struct{}{}
}

// Filter 实现了 Collection 接口的 Filter 方法
func (sc *SetCollection[T]) Filter(predicate func(T) bool) Collection[T] {
    result := NewSetCollection[T]()
    for item := range sc.data {
        if predicate(item) {
            result.Add(item)
        }
    }
    return result
}

// Map 实现了 Collection 接口的 Map 方法
func (sc *SetCollection[T]) Map(transform func(T) T) Collection[T] {
    result := NewSetCollection[T]()
    for item := range sc.data {
        result.Add(transform(item))
    }
    return result
}

// Reduce 实现了 Collection 接口的 Reduce 方法
func (sc *SetCollection[T]) Reduce(initialValue T, reducer func(T, T) T) T {
    result := initialValue
    for item := range sc.data {
        result = reducer(result, item)
    }
    return result
}

// ToSlice 实现了 Collection 接口的 ToSlice 方法
func (sc *SetCollection[T]) ToSlice() []T {
    result := make([]T, 0, len(sc.data))
    for item := range sc.data {
        result = append(result, item)
    }
    return result
}

func main() {
    // 使用 SliceCollection
    numbers := NewSliceCollection([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
    result := numbers.
        Filter(func(n int) bool { return n%2 == 0 }).
        Map(func(n int) int { return n * 2 }).
        Reduce(0, func(acc, n int) int { return acc + n })
    fmt.Println(result) // 输出: 60

    // 使用 SetCollection
    set := NewSetCollection[int]()
    for _, n := range []int{1, 2, 2, 3, 3, 3, 4, 5} {
        set.Add(n)
    }
    uniqueSum := set.
        Filter(func(n int) bool { return n > 2 }).
        Map(func(n int) int { return n * n }).
        Reduce(0, func(acc, n int) int { return acc + n })
    fmt.Println(uniqueSum) // 输出: 50 (3^2 + 4^2 + 5^2)
}

这段代码定义的泛型接口类型Collection包含三个方法：

• Filter：根据条件过滤集合中的元素。
• Map：对集合中的每个元素应用转换函数。
• Reduce：对集合中的元素进行归约操作，比如求和。

其中Filtre、Map都是返回集合自身，这样便允许实现Collection接口的集合类型(如上面的SetCollection和SliceCollection)使用链式调用，代码看起来也十分易于理解。

2.4 递归(Recursion)

递归是函数式编程中常用的控制结构，常用来替代循环。例如下面是计算阶乘的函数实现：

func factorial(n int) int {
    if n <= 1 {
        return 1
    }
    return n * factorial(n-1)
}

递归的优点十分明显，代码简洁，易于理解(相对于循环)，特别适合处理分解问题（如树结构、图遍历等）。但不足也很突出，比如可能导致栈溢出(尤其是对那些不支持尾递归优化的语言，比如Go)，特别是对于较大的输入。此外，由于每次递归调用都需要创建新栈帧，维护栈状态，递归会有额外的性能开销。调试递归函数也可能比循环更复杂，因为需要跟踪多个函数调用。

2.5 惰性求值 (Lazy Evaluation)

惰性求值是指延迟计算表达式的值，直到真正需要它的时候。这样可以避免不必要的计算并有效管理内存，特别是在处理大集合或无限集合时。下面是用惰性求值实现迭代集合元素的示例：

注：Go原生并不支持惰性求值的语法，但我们可以使用闭包来模拟。

// fp-in-go/lazy-evaluation/lazy-range/main.go

package main

import "fmt"

func lazyRange(start, end int) func() (int, bool) {
    current := start
    return func() (int, bool) {
        if current >= end {
            return 0, false
        }
        result := current
        current++
        return result, true
    }
}
func main() {
    next := lazyRange(1, 5)
    for {
        value, hasNext := next()
        if !hasNext {
            break
        }
        fmt.Println(value)
    }
}

我们看到这段代码通过惰性求值方式生成从1到4的数字，避免了预先生成整个范围的集合元素，节省了内存，并避免了不必要的计算。

我们再来看一个用惰性求值生成前N个斐波那契数列的示例：

// fp-in-go/lazy-evaluation/fibonacci/main.go

package main

import (
    "fmt"
)

// Fibonacci 返回一个生成无限斐波那契数列的函数
func Fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

func main() {
    fib := Fibonacci()
    for i := 0; i < 10; i++ { // 打印前10个斐波那契数
        fmt.Println(fib())
    }
}

我们看到Fibonacci函数返回一个闭包，每次调用时生成下一个斐波那契数，这样我们在需要时生成下一个斐波那契数，而无需生成所有。

虽然函数式编程强调纯函数和不可变性，但在实际应用中，我们不可避免地需要处理副作用，如I/O操作、数据库交互等。接下来，我们就来看看在函数式编程范式中是如何处理带有副作用的操作的。

3. 函数式编程对副作用操作的处理

3.1 理解副作用

在函数式编程中，副作用是指函数或表达式在执行过程中对其周围环境产生的任何可观察到的变化。这些变化包括但不限于：

• 修改全局变量或静态局部变量
• 修改函数参数
• 执行I/O操作（读写文件、网络通信等）
• 抛出异常或错误
• 调用其他具有副作用的函数

副作用使得程序的行为变得难以预测和测试，因为函数的输出不仅依赖于其输入，还依赖于程序的状态和外部环境。函数式编程通过最小化副作用来提高程序的可预测性和可测试性。

3.2 Monad: 函数式编程中处理副作用的核心抽象

在函数式编程中，Monad是一种用于处理副作用的核心抽象。它提供了一种结构化的方式来处理计算中的状态、异常、输入输出等副作用，使得程序更加模块化和可组合。

在范畴论中，Monad被定义为一个自函子(endofunctor)加上两个自然变换(有点抽象了)：

• return (也称为unit)：将一个值封装到Monad中。
• bind (也称为flatMap或>>=)：将一个Monad中的值应用到一个函数中，并返回一个新的Monad。

注：要入门范畴论，可以参考《Category Theory for Programmers》这本书。

Monad可以通过以下策略来处理副作用：

• 延迟执行：将副作用操作封装在Monad中，但不立即执行，这样可以将副作用推迟到程序的边缘。
• 显式表示：使副作用成为类型系统的一部分，迫使开发者显式地处理这些效果。
• 组合性：提供了一种方式来组合包含副作用的操作，而不破坏函数的纯粹性。
• 错误处理：提供了一种统一的方式来处理可能失败的操作。
• 状态管理：允许在一系列操作中传递和修改状态，而不需要使用可变变量。

在实际应用中，我们可以根据具体需求选择使用不同的Monad实现。每种Monad都有其适用场景，比如：

• 使用Option(Maybe) Monad处理可能缺失的值，避免空指针异常。
• 使用Result(Either) Monad 处理可能失败的操作，提供更丰富的错误信息。
• 使用IO Monad封装所有的I/O操作，将副作用推迟到程序的边缘。

接下来，我们就结合Go示例来逐一探讨这三种Monad实现。

3.3 Option (Maybe)

Option 用于表示一个值可能存在或不存在，避免了使用null或undefined带来的问题。

// fp-in-go/side-effect/option/main.go

package main

import "fmt"

type Option[T any] struct {
    value   T
    present bool
}

func Some[T any](x T) Option[T] {
    return Option[T]{value: x, present: true}
}

func None[T any]() Option[T] {
    return Option[T]{present: false}
}

func (o Option[T]) Bind(f func(T) Option[T]) Option[T] {
    if !o.present {
        return None[T]()
    }
    return f(o.value)
}

// 使用示例
func safeDivide(a, b int) Option[int] {
    if b == 0 {
        return None[int]()
    }
    return Some(a / b)
}

func main() {
    result := Some(10).Bind(func(x int) Option[int] {
        return safeDivide(x, 2)
    })
    fmt.Println(result) // {5 true}

    result = Some(10).Bind(func(x int) Option[int] {
        return safeDivide(x, 0)
    })
    fmt.Println(result) // {0 false}
}

这段示例程序定义了一个Option结构体：包含一个值和一个表示值是否存在的布尔变量。Some和None函数是Option的创建函数，Some函数：返回一个包含值的Option。None函数返回一个不包含值的Option。Bind方法对Option中的值应用一个函数，如果值不存在则返回None。

3.4 Result (Either)

Result可用于处理可能产生错误的操作，它比Option提供了更多的信息，它可以可以携带错误信息。

// fp-in-go/side-effect/result/main.go

package main

import (
    "fmt"
    "os"
    "strings"
)

type Result[T any] struct {
    value T
    err   error
    isOk  bool
}

func Ok[T any](value T) Result[T] {
    return Result[T]{value: value, isOk: true}
}

func Err[T any](err error) Result[T] {
    return Result[T]{err: err, isOk: false}
}

func (r Result[T]) Bind(f func(T) Result[T]) Result[T] {
    if !r.isOk {
        return Err[T](r.err)
    }
    return f(r.value)
}

// 使用示例
func readFile(filename string) Result[string] {
    content, err := os.ReadFile(filename)
    if err != nil {
        return Err[string](err)
    }
    return Ok(string(content))
}

func processContent(content string) Result[string] {
    // 处理内容...
    return Ok(strings.ToUpper(content))
}

func main() {
    result := readFile("input.txt").Bind(processContent)
    fmt.Println(result) // {HELLO, GOLANG <nil> true}
    result = readFile("input1.txt").Bind(processContent)
    fmt.Println(result) // { 0xc0000a0420 false}
}

这段示例程序定义了一个Result结构体：包含一个值、一个错误信息和一个表示操作是否成功的布尔变量。Ok和Err函数是Result的创建函数，Ok函数返回一个成功的Result。Err函数返回一个失败的Result。Bind方法对成功的Result中的值应用一个函数，如果操作失败则返回错误。

在示例中，我们分别用读取input.txt和不存在的input1.txt来演示成功和错误的两个情况，具体输出结果见上面代码中的注释。

3.5 IO Monad

IO Monad用于封装所有的带有副作用的输入/输出操作，使得这些操作在类型系统中可见，并且可以被推迟执行。

// fp-in-go/side-effect/io-monad/main.go

package main

import (
    "fmt"
    "os"
    "strings"
)

// IO represents an IO operation that, when run, produces a value of type any or an error
type IO struct {
    run func() (any, error)
}

// NewIO creates a new IO monad
func NewIO(f func() (any, error)) IO {
    return IO{run: f}
}

// Bind chains IO operations, allowing for type changes
func (io IO) Bind(f func(any) IO) IO {
    return NewIO(func() (any, error) {
        v, err := io.run()
        if err != nil {
            return nil, err
        }
        return f(v).run()
    })
}

// Map transforms the value inside IO
func (io IO) Map(f func(any) any) IO {
    return io.Bind(func(v any) IO {
        return NewIO(func() (any, error) {
            return f(v), nil
        })
    })
}

// Pure lifts a value into the IO context
func Pure(x any) IO {
    return NewIO(func() (any, error) { return x, nil })
}

// ReadFile is an IO operation that reads a file
func ReadFile(filename string) IO {
    return NewIO(func() (any, error) {
        content, err := os.ReadFile(filename)
        if err != nil {
            return nil, fmt.Errorf("failed to read file: %w", err)
        }
        return string(content), nil
    })
}

// WriteFile is an IO operation that writes to a file
func WriteFile(filename string, content string) IO {
    return NewIO(func() (any, error) {
        err := os.WriteFile(filename, []byte(content), 0644)
        if err != nil {
            return nil, fmt.Errorf("failed to write file: %w", err)
        }
        return true, nil
    })
}

// Print is an IO operation that prints to stdout
func Print(x any) IO {
    return NewIO(func() (any, error) {
        fmt.Println(x)
        return x, nil
    })
}

func main() {
    // Example: Read a file, transform its content, and write it back
    program := ReadFile("input.txt").
        Map(func(v any) any {
            return strings.ToUpper(v.(string))
        }).
        Bind(func(v any) IO {
            return WriteFile("output.txt", v.(string))
        }).
        Bind(func(v any) IO {
            success := v.(bool)
            if success {
                return Pure("File processed successfully")
            }
            return Pure("Failed to process file")
        }).
        Bind(func(v any) IO {
            return Print(v)
        })

    // Run the IO operation
    result, err := program.run()
    if err != nil {
        fmt.Printf("An error occurred: %v\n", err)
    } else {
        fmt.Printf("Program completed: %s\n", result)
    }
}

这个示例提供了一个非泛型版本的IO Monad的Go实现，它允许我们链式组合带有副作用的IO操作，同时保持了一定程度的类型安全（尽管需要类型断言）。在实际使用中，你完全不用自己实现IO Monad，可以直接使用IBM/fp-go中的ioeither，就像本文初那个示例那样。

4. 小结

到这里，关于函数式编程思维的入门介绍就告一段落了！

通过上面的介绍，我们看到函数式编程提供了一种不同于传统命令式编程的思维方式。它强调不可变性、纯函数和函数的组合，为数据流的处理搭建管道，这些特性使得代码更易于理解、测试和并行化。然而，函数式编程也带来了一些挑战，如处理副作用和状态管理的复杂性和难于理解。

学习函数式编程不仅可以扩展我们的编程技能，还能帮助我们以新的方式思考问题和设计解决方案。正如《函数式编程思维》一书中译者所说，接受一种新的编程范式可能需要时间和耐心，但最终会带来新的见解和能力。

在实际应用中，纯粹的函数式编程并不常见，更常见的是将函数式编程的概念和技术与其他编程范式(主要就是命令式范式)相结合。

Go语言虽然不是一个纯函数式语言，但它提供了足够的特性来支持函数式编程风格，如一等公民的函数、闭包和高阶函数等。

最后要记住，编程范式是工具，而不是教条。好的程序员应该能够根据具体问题和场景，灵活地选择和组合不同的编程范式，以创造出最优雅、高效的解决方案。

本文涉及的源码可以在这里下载 – https://github.com/bigwhite/experiments/blob/master/fp-in-go

本文部分源代码由Claude 3.5 sonnet和GPT-4o生成。

5. 参考资料

• 《函数式设计：原则、模式与实践》- https://book.douban.com/subject/36974785/
• 《函数式编程思维》- https://book.douban.com/subject/26587213/
• 《计算机程序的构造和解释》- https://book.douban.com/subject/36787585/
• 《Learning Functional Programming in Go》 – https://book.douban.com/subject/30165168/
• Introduction to fp-go, functional programming for golang – https://www.youtube.com/watch?v=Jif3jL6DRdw
• Investigate Functional Programming Concepts in Go – https://betterprogramming.pub/investigate-functional-programming-concepts-in-go-1dada09bc913
• Investigating the I/O Monad in Go – https://medium.com/better-programming/investigating-the-i-o-monad-in-go-3c0fabbb4b3d

Gopher部落知识星球在2024年将继续致力于打造一个高品质的Go语言学习和交流平台。我们将继续提供优质的Go技术文章首发和阅读体验。同时，我们也会加强代码质量和最佳实践的分享，包括如何编写简洁、可读、可测试的Go代码。此外，我们还会加强星友之间的交流和互动。欢迎大家踊跃提问，分享心得，讨论技术。我会在第一时间进行解答和交流。我衷心希望Gopher部落可以成为大家学习、进步、交流的港湾。让我相聚在Gopher部落，享受coding的快乐! 欢迎大家踊跃加入！

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式：

• 微博(暂不可用)：https://weibo.com/bigwhite20xx
• 微博2：https://weibo.com/u/6484441286
• 博客：tonybai.com
• github: https://github.com/bigwhite
• Gopher Daily归档 – https://github.com/bigwhite/gopherdaily

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

© 2024, bigwhite. 版权所有.

;; 命令式风格
(defun imperative-fibonacci (n)
    (let ((first 0)
          (second 1)
          (sum 0))
        (dotimes (i n)
            (progn
                (setf sum (+ first second))
                (setf first second)
                (setf second sum)))
        first))

;; 函数式风格
(defun functional-fibonacci (n)
    (cond 
        ((= 0 n) 0)
        ((= 1 n) 1)
        (t (+ (functional-fibonacci (- n 1)) (functional-fibonacci (- n 2))))))

对比一下我们可以看出函数式风格代码更加简洁，可读性更强，更易于理解。虽然使用Common Lisp也可以写出命令式风格的代码，不过我们强烈建议你使用函数式风格，这才是Common Lisp的首选范式 – 即用自然而然的函数嵌套调用或递归调用，而不是堆砌一些修改变量值的语句。C语言中也有函数，但与Common Lisp语言中函数的区别就在于其内部实现均为对变量的修改操作，就像上面例子中imperative-fibonacci函数定义的那样。

一、定义新函数
Common Lisp使用defun宏来定义一个新函数，其语法形式如下：
(defun function-name (param*)
    "Optional documentation string."
    expr1
    expr2
    expr3
    … )

其实我在之前的几篇文章以及上面的例子中已经多次用到了defun宏，与C语言的函数原型相比，defun定义的函数缺少了一些类型信息，包括返回值类型信息和参数列表中参数的类型信息。

defun定义的函数在全局作用域可见，即使这个定义是嵌套在另外一个函数定义中的(标准C是不允许函数嵌套定义的)：
[1]> (defun foo (x)
        (print x)
        (defun bar (y)
            (print (1+ y))))
FOO
[2]> (foo 1)
1
BAR
[3]> (bar 2)
3

注意：嵌套在其他函数定义中函数定义，如bar，其生命周期起始于外围函数执行后，例如例子中foo函数未执行前，bar是未定义的。

对于C程序员来说，也许Common Lisp函数定义与C函数定义最大的不同在函数参数列表上。C语言的函数只支持两种参数列表形式：定长参数列表和变长参数列表，比如：
int main(int argc, char* argv[]); /* 定长参数列表 */
int printf( const char* format, …);  /* 变长参数列表 */

而Common Lisp函数对参数列表的支持更加灵活，参数的类型更加丰富，功能也更为强大。下面我们逐一来看。

Common Lisp函数参数列表默认都是定长的，参数也是必选的(required)，也就是说参数列表中有几个形式参数，你在调用该函数时就需要传入等量的实际参数，不能多，也不能少，例如：
[1]> (defun foo (x y) (print (+ x y)))
FOO
[2]> (foo 1)
*** – EVAL/APPLY: too few arguments given to FOO
[3]> (foo 1 2 3)
*** – EVAL/APPLY: too many arguments given to FOO
[4]> (foo 1 2)
3

除了参数列表的必选参数外，Common Lisp还支持可选参数(Optional Parameter)。参数列表中的可选参数由&optional指定，例如：
(defun foo (a b &optional c d)
    (print a)
    (print b)
    (print c)
    (print d))

其中位于&optional后面的c，d为可选参数；如果未显式指定默认值，则其值为NIL。
[1]> (foo 1 2)
1
2
NIL
NIL

我们可以为可选参数指定默认值，例如：
(defun foo (a b &optional (c 10) (d 11))
    … …)
[2]> (foo 1 2)
1
2
10
11

可以看出对于指定了默认值的可选参数，如果调用时没有为可选参数传入实际参数，则可选参数将绑定默认值。可选参数的默认值不仅仅可以是常量值，还可以是全局变量或该可选参数左侧的某个必选参数，例如：
(defvar *x* 13)
(defun foo (&optional a b c (d *x*))
    … …)
和
(defun foo (&optional a b c (d a))
    … …)
 
如果有必选参数，那可选参数必须放在必选参数的后面，但我们可以将一个函数的所有参数都定义为可选参数，如：
(defun foo (&optional a b (c 10) (d 11))
    … …)

在带有可选参数的函数体内我们如何知道该函数被调用时外面是否给可选参数传入实际参数了呢？Common Lisp提供了一个指示器，你可以将该指示器放在可选参数默认值的后面，就像这样：
(defun foo (&optional a b (c 10) (d 11 d-supplied-p))
    (print a)
    (print b)
    (print c)
    (print d)
    (print d-supplied-p))

如果函数在执行时可选参数绑定了实际参数而不是默认值，则该指示器的值将为T，否则为NIL。
[1]> (foo 1 2 3 4)
1
2
3
4
T
[2]> (foo 1 2)
1
2
10
11
NIL

Common Lisp语言引入可选参数至少有两个用途，一是为了适应某些场合的需求：一些场合的确不需要显式为所有参数传递实际参数；二是我们通过可选参数可以为某些参数显式地设置默认值。

在Common Lisp中，与C语言变长参数列表对应的是函数列表中的rest参数。rest参数通过在参数前面的&rest关键字修饰。通过rest参数，我们可以定义出类似format这样接受不定个数参数的函数，例如：
[1]> (defun foo (x y &optional z &rest others)
        (print x)
        (print y)
        (print z)
        (mapcar #'print others))
[2]> (foo 1 2 3 4 "hello lisp")
1
2
3
4
"hello lisp"
(4 "hello lisp")

在函数定义内部rest参数是以一个list的形式存在的，例如上面例子中，传入函数体内的参数others的值实际上是(4 "hello lisp")。

我们知道C语言虽然支持变长参数列表，但其参数列表中至少需要有一个必选参数，例如：int printf( const char* format, …)中的format参数是无法省略的；但是Common Lisp就不同，Common Lisp支持完全的变长参数列表，例如：(defun my-add (&rest addends) …)

Common Lisp还提供一种C语言中没有的参数类型 – keyword参数。keyword参数允许你只为参数列表中的某个特定参数传入实际参数，这种能力是rest和optional参数所不具备的。我们可以通过&key来指示keyword参数，如：
[1]> (defun foo (&key x y z)
        (print x)
        (print y)
        (print z))

作为keyword参数，如果在函数调用时没有为其显式赋值，那么该参数的值将为NIL。我们可以通过如下方式为特定的keyword参数赋值：
[2]> (foo :y 2)
NIL
2
NIL

Keyword参数赋值是不用考虑赋值先后的顺序的，例如：
[3]> (foo :z 11 13)
13
NIL
11

对于带有keyword参数的函数，调用该函数时要么不为任何keyword参数传参，要么至少为其中某一个keyword参数传参，不能只为必选参数传参，如：
[1]> (defun foo (&key x y z)
        (print x)
        (print y)
        (print z))
[2]> (foo 1)
*** – FOO: keyword arguments in (1) should occur pairwise

与Optional参数类似，keyword参数也可以指定默认值，也可以通过指示器来标定keyword参数到底是否绑定了外面传入的实际参数，其中默认值既可以是常量也可以是其左侧其他keyword参数组成的表达式，例如：
[1]> (defun foo (&key (x 17) (y 15 y-supplied-p) z)
        (print x)
        (print y)
        (print y-supplied-p)
        (print z))

[2]> (foo :z 23)
17
15
NIL
23

在之前有关keyword参数的例子中我们使用的形式参数多以x，y这样的简单名字命名，这些名字虽便于函数定义内部使用，但是对于这个函数的调用者来说，这些名字却没有什么实际含义。keyword参数支持通过别名方式解决这个问题：
[1]> (defun foo (&key ((:name a)) ((:age b)) ((:gender c) "Unknown"))
        (print a)
        (print b)
        (print c))
[2]> (foo :name "tony" :age 29)
"tony"
29
"Unknown"

Common Lisp中函数的返回值默认为函数体中最后执行的那个表达式的求值结果，上面举的例子也都是这种情况。在C语言中我们通过return语句可以从函数体内的任何位置主动退出该函数，在Common Lisp中我们同样可以用return-from达到这一目的，例如：
[1]> (defun foo (x y)
        (if (< x 0)
            (return-from foo "IIlegal X Value"))
        (if (< y 0)
            (return-from foo))
        (+ x y))
FOO
[2]> (foo 1 2)
3
[3]> (foo -1 2)
"IIlegal X Value"
[4]> (foo 1 -2)
NIL

对于函数而言，return-from的语法形式为：(return-from func-name optional-value)，若不指定返回值，那么默认return-from的返回值为NIL。

二、匿名函数
与C语言不同，Common Lisp支持定义匿名函数，例如：
[1]> (funcall #'(lambda (x) (print (1+ x))) 2)
3

上面例子中这行语句既包含了函数定义，也包含了函数调用。与之前使用defun定义有名函数不同的是，这次我们定义出来的函数没有指定函数名，这种使用lambda关键字定义的函数被称作为匿名函数。

从例子中也可以看出，匿名函数的定义也很简单，其一般形式为：
(lambda (args*) body-form*)

我们也称这种表达式为lambda表达式。lambda表达式定义的匿名函数与有名函数一样，也支持使用optional，rest和keyword参数。

三、高阶函数
函数式编程语言与命令式语言除了在风格方面的不同之外，最大的不同点之一在于函数式语言中函数已经成为了一等公民(first-class citizen)，与整型、字符串等原生类型具有同等的地位。更具体地说，函数成为一等公民意味着我们可以像对待整型数、字符串那样将函数当作数据对待：将函数赋值给变量、将函数作为参数传递给其他函数以及将函数作为返回值返回给函数调用者等等。作为C程序员你也许会说这似乎与C语言中的函数指针很类似啊，但别忘了C语言真正原生支持的是类型是指针，而不是函数。

有了一等公民地位的函数，我们就得到了高阶函数。高阶函数就是那些接受其他函数为函数或将其他函数作为返回值的函数。例如Common Lisp提供的标准函数sort就接受一个比较函数作为参数：
[1]> (defun integer-over-than (x y) (> x y))
INTEGER-OVER-THAN
[2]> (sort '(5 2 98) (function integer-over-than))
(98 5 2)
[3]> (sort '("hello" "world") (function string>=))
("world" "hello")

标准库中的sort函数接受一个自定义的比较函数作为参数，并在内部将传入的函数应用于参数list。例子中我们没有直接将integer-over-than传给sort，而是使用了(function integer-over-than)。function是Common Lisp提供的一个特殊操作符，将其应用于函数名可以得到该函数名对应的函数对象。比如通过(function foo)，我们可以得到名字为foo的内部函数对象。如果没有foo这个函数定义，解释器会提示"undefined function FOO"。可以看出真正被当作一等公民对待的不是foo这个符号，而是foo这个符号名字背后所对应的那个函数对象，也就是函数在Common Lisp中的内部表示形式。我们在将函数绑定到某个变量或将函数传递给某个函数作为实际参数时，我们都需要使用这个内部函数对象，而不是foo这个符号，例如：
[1]> (sort '(5 2 98) integer-over-than)
*** – EVAL: variable MY-OVER-THAN has no value
[2]> (setf *sort-func* integer-over-than)
*** – EVAL: variable MY-OVER-THAN has no value
[3]> (setf *func* (function my-over-than))
# FUNCTION MY-OVER-THAN (X Y) (DECLARE (SYSTEM::IN-DEFUN MY-OVER-THAN)) (BLOCK MY-OVER-THAN (> X Y))>

Common Lisp提供了一个语法糖用于简化function的使用，即我们可以用#'代替function操作符，比如：#'foo就等价于(function foo)。

那么在接受函数作为参数的函数定义内部我们如何使用函数对象呢？Common Lisp提供了两个函数funcall和apply用来执行函数对象对应的函数。我们先以funcall为例，funcall的语法形式如下：
(funcall function-obj args*)

例如：
[1]> (defun foo (x y) (print (+ x y)))
FOO
[2]> (defun my-add (x y f) (funcall f x y))
MY-ADD
[3]> (my-add 1 2 #'foo)
3

apply与funcall的不同之处在于其接受的参数格式有不同，apply的语法形式如下：
(apply function-obj args* other-args-list)

直观地比较：(apply #'+ '(1 2 3))就等价于(funcall #'+ 1 2 3)，不同的是使用apply需要将各个参数打包到一个list中，或至少保证最后一个参数为list。下面几种调用方式与(apply #'+ '(1 2 3))都是等价的：
(apply #'+ 1 '(2 3))
(apply #'+ 1 2 '(3))

lambda表达式用于定义一个匿名函数，我们同样可以通过#'来获得这个匿名函数对应的函数对象，例如：
#'(lambda (x y) (print (+ x y)))

匿名函数对象可以直接作为实际参数传递给函数，我们也可以通过funcall来直接执行匿名函数，例如：
[1]> (my-add 1 2 #'(lambda (x y) (print (+ x y))))
3
[2]> (funcall #'(lambda (x y) (print (+ x y))) 1 2)
3

以上是推荐的标准用法，下面方法（去掉了lambda前面的#'）虽然也可以达到相同效果，但不推荐使用：
[1]> (my-add 1 2 (lambda (x y) (print (+ x y))))
3
[2]> (funcall (lambda (x y) (print (+ x y))) 1 2)
3
[3]> ((lambda (x y) (print (+ x y))) 1 2)
3

在C语言中我们通过函数指针和回调手法也可以模拟一些高阶函数的行为，这里就不赘述了。

四、闭包(Closure)
市面上有很多编程语言都支持闭包，比如JavaScript，Python，Perl，Ruby等。这里所说的闭包不是离散数学里的那个闭包，而是编程语言引入的一种机制，目前对于编程语言中的闭包尚未有一个精确的定义，但一般认为闭包是引用了外部作用域(但不是全局作用域)的变量的函数，这个被引用的变量与这个函数一同存在，即使是脱离了定义它们的上下文环境。

Common Lisp支持闭包，关于Common Lisp闭包的一个最典型例子是这样的：
[1]> (setf *fn* (let ((i 0))
            #'(lambda () (setf i (+ i 1)))))
#FUNCTION :LAMBDA NIL (SETF I (+ I 1))>
[2]> (funcall *fn*)
1
[3]> (funcall *fn*)
2
[4]> (funcall *fn*)
3

按照之前我们对变量的理解，let引入的i只是一个局部变量，在离开定义的环境后，该变量生命周期将终结。理论上我们三次调用*fn*所对应的你们函数得到的结果应该是相同的才对。但就是由于在let构造的局部作用域内的那个匿名函数引用了外部的变量i，导致变量i可以脱离其原生作用域的束缚，让其生命周期等同于了其内部的那个匿名函数，这个内部的匿名函数就被称为闭包，而那个被引用的外部变量被成为自由变量(free variable)。当我们连续调用函数*fn*时，i就像一个全局变量一样，每次值都加一。

引用了自由变量的闭包似乎是终结了自由变量的局部绑定关系，将自由变量从局部作用域环境中取出，并重新放入一个与闭包同生命周期的新作用域。自由变量会常驻内存中，这也是闭包的常用场景之一。闭包的另外一个用途可能就是出于保护自由变量的考虑，让自由变量只有通过闭包函数才能访问到。

© 2011, bigwhite. 版权所有.

C语言中变量的使用有着严格要求：
第一，在使用一个变量之前必须先声明(或定义)这个变量；
第二，变量声明(或定义)时必须显式指出这个变量的数据类型；
最后，变量类型一旦确定，则在其生命周期内不能改变。
这些也是C语言作为静态编译型语言的特质所决定的。下面代码中关于变量使用的语句在C语言中都是不被允许的：

void foo(void) {
    printf("%d\n", x); /* x变量未被声明或定义 */
}

void bar(void) {
    x;
    printf("%d\n", x); /* 未显式指定x的数据类型，变量声明语句不合法 */
}

与C语言不同，Common Lisp是一门通用的函数式编程语言，其基本编程方法是基于对函数的求值，并要求尽量避免引入可改变的(mutable)变量和状态。另外再加上Common Lisp还是一门动态类型语言，这些都决定了其在变量的使用方面与C语言有着较大的差异。

一、赋值
在C语言中，我们用等号(=)来为变量进行赋值，如：
int a = 13;
char *str = "hello c";
struct foo f = {1, 5, "foo"};

但Common Lisp程序是基于S-expressions的，等号(=)只是一个相等性比较的逻辑判断谓词(predicate)，无法为变量进行赋值。在Common Lisp中，宏setf才是最通用也是最常使用的赋值方法。setf的语法形式如下：
(setf var-expression value-expression)

例如：
[1]> (setf x 5)
5
[2]> (print x)
5
[3]> (setf x "hello lisp")
"hello lisp"
[4]> (print x)
"hello lisp"

从这个例子中我们可以看出三点与C语言的不同之处：
1、Common Lisp变量在使用前是无需显式声明的(当然显式声明也是可以的哦，详见后面说明);
2、变量无类型信息；
3、变量在运行时可以被赋值为多种类型的值，比如此例中x先被赋值为一个整数，后又被赋值为一个字符串。

C语言的变量是内存单元的直接抽象，但Common Lisp中的变量想必不是这样的，它似乎更像是一个void*指针，被赋值为各种类型的对象地址。没错，其实Common Lisp变量的实质是一个引用(reference)，对这类变量赋值的实质就是将引用与存储了真实值的内存块地址绑定起来，setf这个宏达到的实际效果就是改变了引用与值的绑定关系而已。通过这里我们似乎还可以引伸出一点，那就是Common Lisp中的变量本身并不包含类型信息，相反，值才是类型信息的载体，变量的类型取决于变量所绑定的值的类型。

二、局部变量(Local Variable)
作用域是变量的最重要属性之一。根据变量的作用域不同，在C语言中我们可以将变量简单地划分为全局变量(Global Variable)和局部变量。顾名思义，全局变量就是在程序的所有作用域内均可以访问的变量；局部变量恰与之相反，只是在某一特定作用域才可以访问的变量，比如某一函数或代码块内部。Common Lisp也支持这两种类型的变量，我们先从局部变量说起。

与C类似，Common Lisp的局部变量也是在函数内部或代码块内部定义和使用的。Common Lisp通过let宏定义一个局部变量，let宏的语法形式如下：
(let (var*)
     expr1
     expr2
     … )

其中每个var的语法形式为：(name initial-value)，如果未指定initial-value，则变量初值将被设置为nil。最后一个expr的求值结果将作为let的返回值。例如：

[1]> (defun bar ()
        (let ((x 0)) (setf x 4)))
BAR
[2]> (bar)
4
[3]> (print x)
*** – EVAL: variable X has no value

let引入的局部变量x的作用域仅限于bar的内部，在bar外部无法访问到这些变量，变量x的生命周期也是从bar的执行开始，直到bar执行结束为止。

let一次可声明多个局部变量，并可嵌套使用：
[1]> (defun foo ()
        (let ((x 1) (y 2))
            (print x)
            (print y)
            (setf x 3)
            (let ((z 4))
                (print x)
                (print z))))
FOO
[2]> (foo)
1
2
3
4

局部变量的默认作用域属于静态作用域(lexical scope或static scope)，静态作用域是指变量的作用域在执行前即可确定下来，每个函数或代码块中的局部变量均可以在当前函数(或代码块)中或其外层函数(或外层代码块)中找到对应的声明或定义。如上例中，函数foo内有两层let嵌套。外层let引入的变量x和y在当前函数内即可找到对应的定义；最里层的let代码块中使用的变量x在外层的foo函数定义中可以找到相应的定义。一旦找到绑定关系，变量的值就不会因执行环境不同而发生变化了。

和C语言类似，如果局部作用域中的不同层次定义了相同名字的局部变量，那么内层的局部变量将遮盖外层的变量，如：
[1]> (defun bar ()
        (let ((x 1))
            (print x)
            (let ((x 11))
                (print x)
                (setf x (1+ x))
                (print x))
            (print x)))
BAR
[2]>
1
11
12                   
1

求值内层x的值时，Common Lisp找到的是最内层的x定义，最内层的变量x当前绑定值为11，我们看到的输出结果也的确是11。在外层，变量x对应的定义为(x <– 1)，这样外层输出的x的值就为1。

前面例子中定义的函数都是不带参数的，这是故意为之，因为下面我要说函数的形式参数。在C语言中，函数的形式参数与函数内的局部变量是等价的，其作用域也仅局限在函数内部。Common Lisp也是这样的，函数的形式参数本身就可以理解为函数内部的局部变量，在函数被求值时，Common Lisp在函数的形式参数与实际参数间建立绑定关系：
[1]> (defun foo (x)
        (print x)
        (setf x 13)
        (print x))
FOO
[2]> (foo 4)
4
13

从例子中我们可以看出foo函数在求值时，形式参数x与实际参数4建立绑定，第一个(print x)输出结果为4；在foo内部，我们利用setf改变了x的绑定关系后，x值变为13；函数foo内部使用的变量x对应的定义就是foo的形式参数。无论日后foo在什么上下文环境下执行，该x对应的定义都是固定的了，如：
[3]> (let ((x 5)) (foo 4))
4
13

与C语言不同的是，Common Lisp还支持动态作用域(dynamic scope)，这种作用域在如今主流编程语言中已经不常见了。与静态作用域相反，具有动态作用域的变量在执行之前无法确定其定义，也就是说变量的定义不取决于其所在函数或代码块定义时的环境，而是取决于其所在函数或代码块执行时所处的上下文环境，因此其定义或者说绑定关系只能在运行时确定。

对于局部变量，Common Lisp通过(declare (special var-name))来显式声明var-name这个变量为动态作用域变量，又称动态变量(dynamic variable)。动态变量理解起来很不容易，但若明白其实现原理，理解起来就相对轻松许多了。每个动态变量都会对应一个全局绑定关系栈(stack)，在某作用域中遇到一个局部变量定义或新绑定，解释器就会将该新绑定关系压入堆栈；当离开该作用域后，绑定关系被弹出栈。这样当试图确定某个变量的绑定关系时，我们可以直接从栈顶获得绑定关系。如果对应该变量的栈为空时，即判定该变量未绑定任何值，解释器会报错。我们再来通过一个例子来加深一下了解吧：

[1]> (defun foo ()
        (declare (special x))
        (print x))
FOO
[2]> (let ((x 6)) (foo))
*** – EVAL: variable X has no value

我们定义了一个函数foo，在foo中我们声明了x为动态变量。当我们执行(let ((x 6)) (foo))时，解释器提示X没有绑定任何值。这是怎么回事儿呢？我们还是用原理来一步一步分析。

按照执行顺序，解释器先遇到局部变量x的定义，将x与数值6建立绑定，同时确定x为局部变量，但并非动态变量。执行foo时，foo中的变量x为动态变量，解释器为其建立全局绑定关系栈，但是在foo中并没有变量x的定义，所以x对应的全局绑定关系栈为空，导致执行(print x)时出错。

我们修改一下代码：
[1]> (defun foo ()
        (declare (special x))
        (print x))
FOO
[2]> (let ((x 6)) (declare (special x)) (foo))
6

按照执行顺序，解释器先遇到局部变量x的定义，将x与数值6建立绑定，同时发现x被显式声明为动态变量，解释器为x建立全局绑定关系栈，并将其绑定关系(x <- 6)压入栈；接下来执行foo函数，foo中的变量x为动态变量，且当前已经建立全局绑定关系栈，继续执行(print x)，从栈顶得到绑定关系(x <- 6)，得到求值结果，最后解释器离开该作用域，将绑定关系弹出栈。

三、全局变量
与局部变量对应的是全局变量。全局变量拥有全局作用域，即在一个程序内部的任何地方都可以访问到全局变量。Common Lisp通过defvar或defparameter宏显式定义一个全局变量（虽然这不是必须的）：
[1]> (defvar *x* 13)
*X*
[2]> (print *x*)
13
[3]> (defparameter *y* 14)
*Y*
[4]> (print *y*)
14

defvar与defparameter的语法形式如下：
(defvar var-symbol optional-initial-value
      optional-documentation-string)
(defparameter var-symbol initial-value
      optional-documentation-string)

defvar与defparameter的不同之处在于声明中可以不为全局变量绑定初值，而defparameter则是严格要求必须为声明中的全局变量绑定初值，比如:
[1]> (defvar *x*)
*X*
[2]> (defparameter *y*)
*** – The macro DEFPARAMETER may not be called with 1 arguments: (DEFPARAMETER *Y*)

局部变量可以显式地被指定为动态变量，全局变量是否可以呢？我们看看下面的例子：
[1]> (defvar *x* 11)
*X*
[2]> (defun foo ()
        (print *x*))
FOO
[3]> (foo)
11
[4]> (let ((*x* 13)) (foo))
13
[3]> (foo)
11

从例子中我们看出，全局变量本身似乎就是一个动态变量。我们猜的没错。对于使用defvar或defparameter显式定义的全局变量，Common Lisp同时为其赋予了动态属性，也就是说defvar或defparameter定义的全局变量本身就是一个动态变量。其在动态作用域中的工作原理与上面在局部变量中提到的动态变量的原理是相同的。就拿上面的例子来说：
1) 我们使用defvar定义*x*时，解释器就为*x*建立了全局绑定关系栈，并将绑定关系(*x* <- 11)压入栈；
2) 执行(foo)时，解释器从栈顶得到*x*的当前值为11；
3) 执行(let ((*x* 13)) (foo))时，解释器又将动态变量*x*的新绑定关系(*x* <- 13)压入栈，这样在执行后面的(foo)时，栈顶的绑定关系就为(*x* <- 13)，即执行结果为13；当解释器执行体离开该作用域时，绑定关系(*x* <- 13)从栈中弹出；
4) 最后再执行(foo)，栈顶的绑定关系已经变成了(*x* <- 11)，所以(foo)的执行结果又变成了11。

使用setf也可以隐式地引入一个全局变量，但与使用defvar或defparameter显式定义的全局变量不同，setf引入的全局变量并非动态变量：
[1]> (setf *x* 11)
11
[2]> (defun foo ()
        (print *x*))
FOO
[3]> (foo)
11
[4]> (let ((*x* 13)) (foo))
11

在使用源文件编写代码的情况下，我们推荐使用defvar或defparameter定义全局变量。

另外不得不提的是动态变量是把双刃剑，动态变量在函数(子程序)层次之间建立一个隐含的关系，减少了参数传递。但同时也降低了程序的可读性，可靠性以及运行性能。

四、常量
C程序员更喜欢使用宏来表示常量，但Common Lisp提供了专门的defconstant宏来定义一个常量，其语法形式如下：
(defconstant var-symbol value
      optional-documentation-string)

关于常量的内容很简单，但这里还是要注意以下两点：
1、和全局变量类似，Common Lisp常量也有自己的命名惯例，一般以"+constant-name+"为命名格式，名字两旁各加一个加号(+)，不过这个惯例的受重视程度和遵守程度显然不如全局变量那个;
2、常量的名字不能用于作函数的形式参数，比如：
[1]> (defconstant +y+ 2)
+Y+
[2]> (defun foo (+y+) (print +y+))
*** – FUNCTION: +Y+ is a constant, may not be used as a variable

© 2011, bigwhite. 版权所有.

C语言主要有三种控制结构：顺序结构、条件分支结构和循环结构。Common Lisp
也实现了类似的控制结构，我们逐一来看。

一、顺序结构
顾名思义，顺序结构中的语句或表达式是按其位置的先后顺序依次执行的，这也是最简单也最容易理解的一种结构。在C语言中，绝大多数代码块(code block)中的代码都是顺序结构的。Common Lisp程序由S-expressions组成，其本质上的执行过程为自左向右的求值过程。不过Common Lisp的代码编排风格会让给大家一种错觉：Common Lisp似乎也是顺序执行的，例如：

;;以下是来自于《Practical Common Lisp》书中的一段代码
(defun prompt-for-cd ()
  (make-cd
     (prompt-read "Title")   
     (prompt-read "Artist")
     (or (parse-integer (prompt-read "Rating") :junk-allowed t) 0)
     (y-or-n-p "Ripped [y/n]: ")))

Common Lisp确实提供了一个Special operator – progn(注意progn不是函数)，可用于在一个代码块中真正顺序地执行一组表达式。其语法形式如下：
(progn
    (form-1)
    (form-2)
    .
    .
    .
    (form-N))

Common Lisp会顺序地执行form-1，form-2，…. form-N，并将最后一个表达式form-N的求值结果作为progn的返回值，例如：
[1]> (progn
        (print "hello world")
        (print "hello lisp")
        (print "hello graham"))
"hello world"
"hello lisp"
"hello graham"
"hello graham"

最后的"hello gramham"即为progn的返回值，并被顶层环境再次输出。progn的行为让我想起了C语言中的逗号表达式"expr1, expr2, … , exprn"，与progn一样，逗号表达式也是依次执行expr1，expr2，…，并返回最后一个expression的值。

二、条件分支结构
C语言中最常见的条件分支结构莫过于if语句了。if语句是一个典型的开关结构或叫二选一结构，即if后面的条件成立，执行一个分支；否则执行另外一个分支。其典型结构如下：
if (cond expr) {
    … …
} else if (cond expr) {
    … …
} else if (cond expr) {
    … …
} else {
    … …
}

Common Lisp中也有if。与progn一样，Common Lisp中的if也是一个special operator而不是函数。函数的原则是必须对所有参数都进行求值，且对每个参数仅进行一次求值；而if和progn则不一定需要对所有"参数"进行求值。Common Lisp中if的语法形式如下：
(if cond-form
    then-form
    [else-form])

Common Lisp中的if首先对cond-form进行求值，如果为真，则对then-form求值，并将结果返回；否则返回else-form的求值结果。如果没有else-form分支，则返回nil。这与C语言中的条件表达式："condition_expression ? then_expression : else_expression"甚为相似。下面是一个例子：

[1]> (if (> 3 2) (+ 4 5) (- 11 3))
9
[2]> (if (< 3 2) (+ 4 5) (- 11 3))
8
[3]> (if (< 3 2) (+ 4 5))
NIL
[4]> (if (= 2 2)  ;; if级联示例
        (if (> 3 2) 4 6)
        9)
4

除了if，Common Lisp还提供了其他一些简便实用的条件分支控制operator。

我们常常会在某个条件分支中顺序地执行多个表达式，这种情况下，我们用if实现的代码如下：
(if (cond-form)
    (progn
        (form1)
        (form2)
        (form3)))

Common Lisp提供了操作符when来应对如此需求，并简化你的代码：
(when (cond-form)
        (form1)
        (form2)
        (form3))

当cond-form求值为真时，when会顺序从form1执行到form3。

Common Lisp还提供了unless，用于否定语义的判断：
(unless (cond-form)
        (form1)
        (form2)
        (form3))

仅当cond-form求值为nil时，form1到form3才会被顺序执行，否则返回nil。

我们日常还会遇到条件分支特别多的情况，如：
if (cond-1)
    statments-1
if (cond-2)
    statments-2
… …
if (cond-n)
    statments-n

此时如果用if来实现，代码就显得层次太深，不够简洁，可读性不好，也难于后续维护：
(if (cond-1)
    (statments-1)
    (if (cond-2)
        (statments-2)
        …..
            (if (cond-n)
                (statments-n))))

Common Lisp提供了cond操作符来应对这一情况：

(cond
    ((cond-1) (statments-1))
    ((cond-2) (statments-2))
    … …
    ((cond-n) (statments-n)))

C语言中还有一种分支结构switch…case，可用于将一个变量与诸多常量相比较。变量与哪个case中的常量相等，就继续执行该case所在的分支代码。有些资料中将该结构称为选择结构，这里我把它统一划归在条件分支一类中。因为只有满足case条件，执行权才会进入到这个分支：
switch (expression) {
    case (const expression):
        statments;
        … …
    case (const expression):
        statments;
    default:
        statments;
}

Common Lisp中也有与switch…case对应的结构：case。
[1] > (defun grade-meaning (grade)
        (case grade
            ((5) "Excellent")
            ((4) "Good")
            ((3) "Average")
            ((2) "Poor")
            ((1) "Failing")
            (otherwise "Illegal grade")))
GRADE-MEANING
[2]> (grade-meaning 5)
"Excellent"
[3]> (grade-meaning 1)
"Failing"
[4]> (grade-meaning 0)
"Illegal grade"

case结构中的otherwise类似与C语言中switch…case中的default分支，用于处理默认情况。我们也可以用t代替otherwise，其语义是一样的：
[5] > (defun grade-meaning (grade)
        (case grade
            ((5) "Excellent")
            ((4) "Good")
            ((3) "Average")
            ((2) "Poor")
            ((1) "Failing")
            (t "Illegal grade")))

三、循环结构
和前两种控制结构相比，循环结构相对更加复杂一些。C语言提供了三种循环结构：for，do-while和while。而在Common Lisp中最通用也最灵活的循环结构为do宏。

do宏的语法形式如下：
(do ((var init-form step-form)*)
    (end-test-form result-form*)
  statement*)

和C语言中的for语句相似，do宏的执行过程也比较复杂：
1) 在初始化阶段，即循环未开始前，init-form被求值，求值结果赋给var；
2) 求值end-test-form，如果为nil，则进入子循环体，执行statement*; 如果为真，则求值result-form，并将求值结果作为do的返回值，循环结束;
3) 每个子循环执行完毕后，都会求值step-form，并用求值结果更新var；
4) 重复执行步骤2)

我们用个例子来分析一下这个执行过程，下面是一个求0到2的累加和的例子：
(do ((i 0 (1+ i))
     (sum 0 (+ sum i)))
   ((> i 2) sum))

1) 初始化：i = 0, sum = 0
2) 求值end-test-form，判断终止条件是否成立，(> 0 2)为nil，进入子循环;
3) 循环体为空，求值step-form，即i <- 0 + 1，结果i = 1; sum <- sum + i = 0 + 0(注意：这里的i用的是更新前的旧值)，结果sum = 0; 
4) 求值end-test-form，判断终止条件是否成立，(> 1 2)为nil，进入子循环;
5) 循环体为空，求值step-form，即i <- 1 + 1，结果i = 2; sum <- sum + i = 0 + 1 = 1; 
6) 求值end-test-form，判断终止条件是否成立，(> 2 2)为nil，进入子循环;
7) 循环体为空，求值step-form，即i <- 2 + 1，结果i = 3; sum <- sum + i = 1 + 2 = 3; 
求值end-test-form，判断终止条件是否成立，(> 3 2)为t，求值result-form，即sum = 3，do循环结束，返回值3。

do宏通用性强，但语法及行为复杂。为了简化代码，方便使用，针对两种常见情况Common Lisp基于do宏又提供了dotimes和dolist两个宏。

dotimes宏顾名思义，适用于多次重复执行某个动作，其语法形式：
(dotimes (var max-count-form)
  body-form*)

其执行流程照比do宏要简单的多，注意max-count-form求值结果必须为一数值：
1) var初始化为0
2) 检查循环结束条件：如果var小于max-count-form的求值结果，则求值body-form；否则返回nil
3) var <- var + 1
4) 重复执行步骤2)

例如：
[1] > (dotimes (i 2) (print i))
0
1
NIL

dolist宏适用于迭代处理一个list中的诸多元素，其语法形式如下：
(dolist (var list-form)
  body-form*)

其执行流程大致如下：
1) var初始化为list-form的第一个元素
2) 检查循环结束条件：如果var不为nil，则求值body-form；否则返回nil
3) var被赋值为list-form中的下一个元素
4) 重复执行步骤2)

例如：
[1]> (dolist (i '(1 2 3))
        (print (* 2 i)))
2
4
6
NIL

[2]> (defun integer-list-sum (x)
        (let ((sum 0))
            (dolist (i x)
                (setf sum (+ sum i)))
            (print sum)))
INTEGER-LIST-SUM
[3]> (integer-list-sum '(1 2 3 4))
10

在C语言中，我们可以通过break从循环中主动退出。Common Lisp同样也提供了"break"特性，不过Common Lisp用的是return，例如：

[1]> (do ((n 0 (1+ n))
          (cur 0 next)
          (next 1 (+ cur next)))
       ((= 10 n) cur)
       (if (oddp cur)
           (progn
               (print cur)
               (return))))
1
NIL

有了三种控制结构，我们就可以用Common Lisp编写出更加富有表现力的实用代码了。以上只是Common Lisp提供的标准控制结构。别忘了，Common Lisp可是一门可编程的编程语言，我们完全可以根据自己的需要定义出更加简洁方便的控制结构，不过这是高级话题了。等我们学到宏的时候再考虑这些吧。现在的首要任务就是熟练掌握这些基本的控制结构^_^。

© 2011, bigwhite. 版权所有.

每个Lisp表达式都可以提交给Common Lisp解释器进行求值，并得到一个求值结果。这里我们从简单的原子说起。

一、原子
原子虽然十分简单，但它也是一种表达式。对于原子而言，其求值结果就是其自身的值。下面我们来看看一些常见的原子以及其求值结果：

(1) 数字(Number)
数字是一种原子，其求值结果即为其自身数值。

* 整型数字
[1]> 13
13
[2]> -4
-4
[3]> 0
0
[4]> #xa    ;; 16进制数
10
[5]> #o11   ;; 8进制数
9
[6]> #b011  ;; 二进制数
3
[7]> #24r1n ;; 24进制数
47

最后的#24r1n是一种通用N进制数表示形式，N取值范围为2到36，其表示形式为#Nr…。

* 浮点数
[1]> 3.1415
13
[2]> 365e0
365.0
[3]> 365e-3
0.365
[4]> 365f-3
0.365
[5]> 365d-3
0.365d0
[6]> 0.365e20
3.65E19

标志f表示单精度浮点数，标志d表示双精度浮点数，标志e表示默认采用单精度，与f相同。

* 分数
[1]> 5/6
5/6

* 复数
[1]> #C(1.2 3)
#C(1.2 3)

C(1.2 3)对应的复数为1.2+3i。

(2) 字符(character)
单独的字符也是原子，其求值结果也是其自身值。

下面是一些可见字符：
[1]> #\a
#\a
[2]> #\A
#\A
[3]> #\%
#\%
[4]> #\&
#\&

一些常见的控制字符的形式如下：
[1]> #\newline
#\Newline
[2]> #\tab
#\Tab
[3]> #\backspace
#\Backspace
[4]> #\space
#\Space
[5]> #\escape
#\Escape

(3) 字符串(string)
与C语言中的字符串不同，Common lisp中字符串结尾并不包含''。但字符串也是原子，其求值结果依旧是其本身。

[1]> "Hello, Common Lisp!"
"Hello, Common Lisp!"

我们可以字符转义将一些特殊字符放入字符串，比如我们可以在字符串中包含双引号：
[2]> (format t "~A ~%" "He said \"I am going to see Harry Potter!\" and then he left.")
He said "I am going to see Harry Potter!" and then he left.
NIL

不过我们无法通过转义方法将tab字符、回车符、换行符放入字符串，只能通过键盘手工输入：
[3]> "Look, here are      tabs      and some

returns!

Understand?"
"Look, here are      tabs      and some

returns!

Understand?"

(4) 布尔类型(bool)
布尔值也是原子，但只有两个可选值：t和nil。t代表true，nil代表false，由于比较简单，这里就不细说了。

(5) 符号(symbols)
与C语言不同的是，Common Lisp中有一种语法元素称为"符号"。符号有些类似于C语言中的标识符，用来表示Lisp程序中使用的名字，诸如函数和变量的名字，像format，hello-foo, *counter*等。Lisp符号的包容性更强，像+，-等在C中为操作符关键字的字符都可以作为符号。

(a b c)       ; 一个包含三个符号的list
(a 2 "bar")   ; 这个list包含一个符号，一个数字和一个字符串
(+ (* 2 3) 4) ; 这个list包含一个符号，一个列表以及一个数字

符号的求值比较特殊，如果该符号没有绑定到任何值，解释器会提示错误。如果绑定了值，则显示绑定的值：
[1]> a

*** – EVAL: variable A has no value
The following restarts are available:
USE-VALUE      :R1      You may input a value to be used instead of A.
STORE-VALUE    :R2      You may input a new value for A.
ABORT          :R3      Abort main loop
Break 1 [2]> :r3
[3]> (setf a 5)
5
[4]> a
5

二、列表
在实用程序中，我们很少将原子单独作为表达式，我们更多使用的是List，即列表。之前说过Common Lisp的核心就是List，此List不同于我们以往数据结构中学习的那个List，在Common Lisp中，List是程序和数据的载体，别忘了Lisp是"LISt Processing"的缩写，直译过来Lisp就是List处理语言，这也凸显了List在Lisp语言中的核心地位。

绝大多数情况下，Lisp程序字面上就是一组列表集合。掌握对List进行求值的方法就显得尤为重要了。

我们先从一个简单到不能再简单的List入手：
[1]> (+ 1 2)
3

这个List由三个原子组成，一个符号以及两个数字。Common Lisp解释器会首先检查第一个元素是否是一个符号并且是否是一个绑定了有效函数的符号。如果不符合条件则报错。如果第一个元素是符号且绑定合法函数，如+，那么解释器会将后续的元素作为该函数的参数，并自左向右对参数逐个进行求值。

[1]> (length "hello lisp")
10
[2]> ("foo" 1 2)

*** – EVAL: "foo" is not a function name; try using a symbol instead
The following restarts are available:
USE-VALUE      :R1      You may input a value to be used instead.
ABORT          :R2      Abort main loop

在(+ 1 2)这个例子中，+是一个符合条件的符号，解释器接下来对1和2这两个原子进行求值，前面提到整数是原子，其求值结果即为自身值，所以解释器将1和2传给+，得到最终结果3。

Common Lisp的解释器对参数的求值是自左向右递归进行的，下面是一个稍复杂的表达式，其详细的求值过程如下：

(+ (- 7 (/ 4 2)) (* 3 4))
-> (+ (- 7 2) (* 3 4))
-> (+ 5 (* 3 4))
-> (+ 5 12)
-> 17

解释器从左向右依次对参数进行求值，解释器遇到函数+的第一个参数(- 7 (/ 4 2))，这显然是也是一个减法表达式，解释器递归地对该表达式进行求值；(- 7 (/ 4 2))表达式的第一个参数7为原子类型，其求值结果为自身值7；第二个参数又是一个除法表达式，解释器再一次进行递归求值，进入(/ 4 2)，这是个简单表达式，其求值结果为2；求值程序回到表达式(- 7 2)，得到求值结果5，至此最外层表达式的第一个参数求值完毕，结果为5；解释器继续对最外层表达式的第二个参数(* 3 4)进行求值，这是个乘法表达式，对该表达式求值结果为12，这样我们的顶层表达式就变成了(+ 5 12)，则最终求值结果就为17。这个过程有点类似于树遍历算法中的深度优先遍历算法。

无论是多么复杂的表达式，Common Lisp解释器的求值方法都是如此的。当然解释器不一定会将函数的所有参数都进行求值，比如：(if t 5 (+ 6 7)这个表达式在if条件为t时，只会求值5这个参数，(+ 6 7)这个表达式不会被求值。

© 2011, bigwhite. 版权所有.

也许有人会问："C语言已经无所不能了，为何还要学习Common Lisp？"在这里我不想说太多冠冕堂皇的话，至少对我而言，理由有三：
一是好奇，在C语言的世界里待得久了，总想探出头来吸几口新鲜空气，这次我选择了Common Lisp；
二是为了变成一名更好的程序员。为何学习Common Lisp就能成为一名更好的程序员呢？这不是我的观点，而是诸多牛人或大师们（包括Paul Graham、Peter Norvig以及另外一个Peter：Peter Seibel等）的观点。不过不管你们信不信，反正我是信了。这个观点的关键思想就是一门语言可以影响一个程序员的思维方式。我相信Common Lisp可以给我带来一种不同于以往的新的编程思维方式，这样至少比只有一种思维方式要好，不是吗；
最后，Lisp是一门可编程的编程语言，可以很容易扩展自身并且创造一门新的语言。我无法不动心于如此一门强大的语言。

学习总是需要一些付出的。Jolt大奖得主《Practical Common Lisp》的作者Peter Seibel花了一年的时间放下一切潜心学习Common Lisp并终有所成。我们还有工作，有生活压力，无法像Seibel那样潇洒，但我们依旧可以去学习Common Lisp，循序渐进地学，一步一步来"驯服"Common Lisp这个"猛兽"。"猛兽"被驯服后，才能为你所用，发挥出异常的威力，不是吗？我们需要的仅是恒心和足够的耐心罢了。

"驯服"意味着"学会"，何为学会一门语言？只是知晓语法，看懂代码还远远不够，那些仅仅叫知道或了解或"纸上谈兵"，还谈不上真正地"学会"。古人云："学以致用"，只有在实际中可以灵活自如的使用了，才叫真正的"学会"了。

现在只是开始！这里我会按照C程序员学习C语言的逻辑展开，为了更加贴近C程序员的思维模式，我选择了这种相对平滑的学习方式。也许最初的几篇会让你觉得Common Lisp很像一门命令式语言^_^！

言归正传！学习一门编程语言之前，最好先弄清楚该语言在当前众多语言中的位置，了解一下它的前世今生，这有助于你对这门语言的认知。不过关于Common Lisp的详细历史这里就不赘述了，在进行下面内容之前，请先阅读一下维基百科，或是读读几本经典Common Lisp书籍（如《ANSI Common Lisp》、《On Lisp》以及《Practical Common Lisp》等）中对Common Lisp历史的介绍。

Common Lisp是Lisp语言大家族中的一分子，和Scheme等一样，它也是一门Lisp方言(Dialect)。与C语言相比，Lisp更加古老，是史上第二古老的编程语言，仅次于Fortran。但Common Lisp比C年轻，它是在上世纪80年代诞生的。与C语言普遍采用的"编辑->编译->调试/执行"的工作方式不同，Common Lisp更多采用的是类似于Python、Ruby那样的交互式的解释器工作模式。你在Common Lisp交互环境中就可以完成上述C语言的所有步骤。这种方式目前看来更易于语言的学习（虽然C语言目前也有解释器的实现，如Ch，但C程序员似乎更喜欢传统方式）。

目前市面上Common Lisp的实现有很多种，既有商业收费的，也有开源免费的。商业软件这里就不提了，常用的免费开源的主流Common Lisp解释器包括CLISP、SBCL(Steel Bank Common Lisp)和Clozure CL。我个人更喜欢使用CLISP，所以后续有关解释器方面的内容更多以CLISP为主。

CLISP支持诸多平台，你可以很容易得到安装包并顺利的完成安装，关于这方面内容这里就不赘述了。打开一个终端（Windows下打开一个命令行窗口)，敲入"clisp"，回车，你就进入到CLISP提供的Common Lisp顶层环境(Top-Level)当中了(若要进入SBCL，敲入sbcl；若要进入Clozure CL，敲入ccl，以上的前提是这些包的可执行程序路径已经加入到你的PATH环境变量中了)，就像这样：

$ clisp
… …
Welcome to GNU CLISP 2.44.1 (2008-02-23) <http://clisp.cons.org/>

Copyright (c) Bruno Haible, Michael Stoll 1992, 1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2008

Type :h and hit Enter for context help.

[1]> _

对于所谓的"顶层环境"，熟悉Python和Ruby等解释型语言的朋友并不陌生。它就是一个已经加载了标准Common Lisp包的REPL环境。其中REPL是Read-Eval-Print-Loop的缩写。说白了，这就是一个Common Lisp代码的执行环境，你在里面可以输入Common Lisp代码，这些代码可以被直接执行，执行结果也会立刻展现在你的眼前，或如果遇到错误/异常时，你还可以在里面直接进行代码调试。当然了"顶层"还有一个范围(Scope)的概念在里面，用于区分不同变量和函数的作用域。

我们在CLISP中输入一些字符串、字符以及数字以及简单表达式：

[1]> "hello lisp"
"hello lisp"
[2]> #\c
#\c
[3]> 1
1
[4]> (+ 1 2)
3

CLISP对于我们的输入给予了回应：对于字符串、字符(注意Common Lisp的字符表示法很特别，以#\作为前缀，#\c即C语言中的'c')以及数字，CLISP进行了回显（实际上是对输入求值后的结果），对于"(+ 1 2)"这个计算1和2之和的表达式，CLISP给出了求值后的结果。

我们继续输入一个a：

[5]> a

*** – EVAL: variable A has no value
The following restarts are available:
USE-VALUE      :R1      You may input a value to be used instead of A.
STORE-VALUE    :R2      You may input a new value for A.
ABORT          :R3      Abort main loop
Break 1 [6]>

与前面不同的是，这次CLISP给出了错误提示，求值器（evaluator)无法找到a绑定的值，CLISP进入异常处理模式，或称作调试模式。CLISP给出了三种选择：我们选择输入:R3，可以回到top-level主循环；选择输入:R2，则可以为a赋值。

Break 1 [6]> :R2
New A: 5
5
[7]> a
5

SBCL和Clozure CL与CLISP类似，都会有类似的调试模式，退出调试模式的方法参见各自的提示说明即可。

如果要退出CLISP解释器，我们可以输入"(quit)"，注意quit两边的括号也是命令的一部分；在SBCL中，我们可以输入(SB-EXT:QUIT)退出；Clozure CL的退出方法与CLISP相同。

Common Lisp源代码是由一组S-expressions(symbolic expression)构成的。什么是S-expression呢？这个在Common Lisp书籍中很难找到答案，因为S-expression是一种组织数据的结构，并不是Lisp独有的，只是Lisp恰好也采用了这种结构来组织存储Lisp的代码和数据罢了。在维基百科上，S-expression有一个递归的定义："S-expression要么是一个被成为原子(atoms)的单一的数据对象(data object)，要么是一个S-expressions列表(list)。数字、数组、字符串以及符号都是原子"，比如：

[1]> 13
13
[2]> #(1 2 3)
#(1 2 3)
[3]> "hello"
"hello"
[4]> #'length
#

数字'13'、数组'#(1 2 3)'、字符串"hello"以及符号'length'都是原子。

Lisp将代码和数据都存储于S-expressions当中，这是Lisp与其他主流语言的最大区别之一。我们在编写Common Lisp源码时，需要遵循正确的S-expression格式。前面说过Common Lisp解释器就是一个READ-EVAL-PRINT-LOOP环境，这个环境主要由一个Reader和一个Evaluator构成。Reader负责读取源文件中的文本或者我们在提示符后面输入的文本，检查文本格式是否符合S-Expression要求，直到所有文本都符合格式要求，这样解释器就得到了正确的S-expression：

[1]> (+ 1 2))
3
[2]>
*** – READ from … >: an object
      cannot start with #\)

通过上面例子可以看出，Reader识别出了不符合S-expression格式的源码文本。

Reader将文本转换为S-expressions后，Evaluator就开始对S-expression进行校验，校验其是否符合Lisp Code的规范形式(Lisp Form)。

下面的例子说明了Evaluator的作用：

[1]> (foo 1 2)
*** – EVAL: undefined function FOO

毫无疑问，(foo 1 2)是一个有效的S-expression，其通过Reader这关是没有问题的。但是当Evaluator对S-expression"(foo 1 2)"进行验证求值时，却发现无法找到函数foo的定义，这行源码不合法。

简单总结Reader和Evaluator的工作流程就是："源码文本"通过Reader转换为有效的"S-expressions"，后者则由Evaluator转换成有效"Lisp Form"并求值得出结果。

Common Lisp初学者常常被那满眼的括号所吓住，不过事实上括号并没有那么"可怕"。括号其实主要是给Common Lisp解释器(Reader和Evaluator)用的，而不是给程序员看的。现今的代码编辑器都很智能，基本上可以消除括号在编程过程中给你带来的影响（要说一点影响没有也不太可能）。

Common Lisp支持多种注释形式。在C语言中我们用'//'进行单行注释(C99标准引入)，而Common Lisp的单行注释符号为';'。C语言采用'/*…*/'进行多行注释，Common Lisp使用的是'#|…|#'。Common Lisp还提供了一种大多语言都不具备的注释方式，那就是将注释直接写到紧邻函数定义的参数列表后面的位置上，这样通过Common Lisp提供的工具，我们可以轻松地提取出该函数的注释，并生成代码文档，比如：

[1]> (defun foo (x) "test comments" (+ x 1))
FOO
[2]> (documentation #'foo t)
"test comments"

由于Common Lisp括号众多，一个风格良好的Lisp程序需要通过良好风格的代码缩进来保证，这方面我推荐AI领域大师Peter Norvig若干年前编写的一篇有关优秀Lisp编程风格的文章《Tutorial on Good Lisp Programming Style》。

很多C程序员可能还是习惯于将代码写到文件中。Common Lisp解释器提供了将你的源文件加载到顶层环境并直接使用其中的定义的方法：
;; foo.lisp
(defun foo (x) "test foo"
   (+ x 1))

[1]> (load "foo.lisp")
;; Loading file foo.lisp …
;; Loaded file foo.lisp
T
[2]> (foo 5)
6

利用load函数我们可将你的源文件加载到顶层环境中，并在顶层环境里使用该源文件中定义的函数。

编程语言初学者总喜欢在终端控制台上看到自己编写的程序的输出结果，那样会产生一种奇妙的成就感，程序员们多陶醉于其中。C程序员最常用的就是printf函数了，Common Lisp中也有与printf等价的函数，它就是format。这里不是专门讲解format函数的，下面仅仅列举一些常见的例子，这些例子应该可以满足你在学习语言初期的需求了：

* 输出整型数
(format t "~d" 1000000) ==> 1000000
(format t "~x" 1000000) ==> f4240
(format t "~o" 1000000) ==> 3641100
(format t "~b" 1000000) ==> 11110100001001000000

上面依次是按十进制、16进制、八进制和二进制输出。

* 输出浮点数
(format t "~f" 3.1415) ==> 3.1415

* 输出字符串
(format t "~a" "hello lisp") ==> hello lisp

* 输出字符
(format t "~c" #\c) ==> c

* 输出换行符
以下借用《ANSI Common Lisp》书中的一个例子：
(format nil "Dear ~a, ~% Our records indicate…" "Mr. Malatesta")
==> "Dear Mr. Malatesta,
 Our records indicate…"

format函数的第一个参数表示是否输出到"标准输出(*STANDARD-OUTPUT*"，如果传入t，则表示输出到标准输出设备上。第二个参数与C中的printf函数的第一个参数类似，是一个格式串，不同的是格式串中的指示符(directive)由printf中的'%'变成了'~'。

为了让大家更加直观地了解Common Lisp源代码到底是什么样子的，下面将给出一个Common Lisp的例子程序，这个程序用来计算参数字符串中大写字母的总个数：

我们先给出一个命令式风格的实现版本：
;; upper-char-counter.lisp
(defun upper-char-counter (str)
  (let ((len (length str)) (result 0))
      (do ((i 0 (+ i 1)))
          ((>= i len) result)
        (if (upper-case-p (char str i)) (setf result (1+ result))))))

即使你不懂Common Lisp语法，你也能大致猜测处理这段代码的逻辑，基本上与下面C代码是等价的：
int upper_char_counter(const char *str) {
    int result = 0;
    int len = strlen(str);

    int i = 0;
    while (i < len) {
        if (str[i] >= ‘A’ && str[i] <= 'Z') {
            result++;
        }
        i++;
    }

    return result;
}
 
下面是一个函数式风格的实现版本：

;; upper-char-counter.lisp
(defun upper-char-counter (str)
   (count-if #'upper-case-p str))

[1]> (load "upper-char-counter.lisp")
;; Loading file upper-char-counter.lisp …
;; Loaded file upper-char-counter.lisp
T
[2]> (upper-char-counter "a5B6CD!")
3

这个版本的代码显然更加简洁，但理解起来有些难度。函数count-if接受一个函数和一个字符串作为参数，count-if将函数upper-case-p应用于str中的各个字符上，并将返回true(t)的结果个数累加得到最终返回值。

走到这里，我想大家应该对Common Lisp有了一个感性的认识了，至少可以编写一些命令式风格的简单代码或复制一些现存的代码放到顶层环境中执行了。如果真的是这样，那我的目的就达到了^_^。

© 2011, bigwhite. 版权所有.

俗话说：工欲善其事，必先利其器。Common Lisp开发者们也有着自己一套高效的开发工具。目前无论是在Windows还是在Linux或是其他平台上，最受Lisper们推崇的工具组合是Emacs+ Slime(The Superior Lisp Interaction Mode for Emacs)。鼎鼎大名的Emacs这里就不说了，Slime对于很多非Lisp开发者来说是一个陌生的名字，我们可以把它看成是一种专门为Lisper们提供的一个嵌入到Emacs中的IDE，通过它我们可以在Emacs编辑器中直接进行Lisp代码的求值，编译，宏扩展，符号定义的查找，名字的自动补全以及在线文档查询等操作。我平时开发更多使用的是另外一种编辑神器-VIM，幸运的是已经有人将Slime移植到了Vim下，Slime摇身一变，变成了Slimv（The Superior Lisp Interaction Mode for Vim）。由于接触时间较短，我目前尚不确定在功能上Slimv是否完全等同于Slime。不过就目前来看，Slimv的确让Vim下Common Lisp代码的编写变的高效了许多。

Slimv的安装极其简单：将Slimv包下载到你的$HOME/.vim下（这里以Linux下的安装为例），直接解压即可。Slimv首先为Vim提供了一种名为Paredit Mode(.vim/doc/paredit.txt )的编辑模式，这种模式专门针对Lisp代码源文件，诸如以.lisp为后缀名的文件。该编辑模式保证内容中所有括号、方括号以及双引号均平衡出现，即成对匹配。当你敲入"("，该模式会自动补充对应的")"；删除半个括号时，另半个括号也被自动删除。初次使用Paredit mode很不习惯，特别是不知如何在括号的外层再包裹一层括号，也就是将(list 1 2)变为((list 1 2))。每次在(list 1 2)开始处输入"("，都会得到"()(list 1 2)"。后来才在Stackoverflow上觅到答案：原来先输入"\"再输入"("时，Slimv不会自动补充")"，通过这种方式可以在括号的外围再加上一层括号了，在Lisp实际编程过程当中，嵌套括号的情况还是很多的。

打开一个名为xx.lisp的源文件，Slimv就会自动发挥作用。在Vim的命令模式下，敲入",c"，Slimv会自动启动Swank Server，这个Server运行着一个Common Lisp的REPL，接收并处理嵌入在Vim中的Slimv client端发出的求值、编译、调试等请求，保存你在Vim中与REPL的session内容。Slimv同时会在Vim里创建一个REPL窗口，不过这仅是用来等待你的输入，真正的求值等操作是在Swank Server完成的。

Slimv会自动Detect你已安装的Common Lisp实现，在我的已经安装过Clisp和SBCL的系统中，Slimv优先选择了SBCL。 关于Slimv，这里不再多说什么了，因为其作者已经编写了一份很详尽的Tutorial在这里，有兴趣的朋友可以参考之。

我在读的Common Lisp书籍主要有两本：一本是"黑客与画家"的作者Paul Graham编写的"ANSI Common Lisp"，另外一本则是Peter Seibel的"Practical Common Lisp"(据说该书的中文译本已由binghe完成)。这一周多来，我快速地浏览了Peter Seibel的"Practical Common Lisp"，除了惊奇于一些之前未曾接触过的特殊语法结构（如Closure）之外，也感叹于Common Lisp的复杂，数不尽的function, macro和special operator让我有些迷失和混淆。另外Peter Seibel自称书中有关macro的例子都很初级，但就是这样初级的macro也是甚难以理解的。关于macro的深入领会，我看只能指望Paul Graham的大作："ANSI Common Lisp"和"on lisp"了。

另外一本名为"Common Lisp Quick Reference"的小书也值得一看，不过更适合Common Lisp老手查阅手册时使用。

浏览完"Practical Common Lisp“后，继续精读"ANSI Common Lisp"，并且对其中的习题也不放过。这些练习估计很初级，不过对于我这个初级选手来说正合适。刚刚看完第二章(Welcome to Lisp)，这里将我的习题答案放到这里，供大家批评指正：

练习1.
(a) 14
(b) (1 5)
(c) 7
(d) (NIL 3)

练习2.
[1]> (cons 'a '(b c))
(A B C)
[2]> (cons 'a (cons 'b (cons 'c nil)))
(A B C)
[3]> (cons 'a (list 'b 'c))
(A B C)

练习3.
[1]> (defun my-fourth (x)
          (car (cdr (cdr (cdr x)))))
MY-FOURTH
[2]> (my-fourth '(1 2 3 4 5))
4

练习4.   
[1]> (defun my-max (x y)
         (if (> x y) x y))
MY-MAX
[2]> (my-max 5 6)
6
[3]> (my-max 7 6)
7

以上方案只适用于整数等适用>进行比较的类型，下面是一个更加通用的版本：

[1]> (defun my-max1 (x y comp_func)
         (if (funcall comp_func x y) x y))
MY-MAX1
[2]> (defparameter *cf* (lambda (x y) (if (> x y) t nil)))
*CF*
[3]> (my-max1 5 6 *cf*)
6
[4]> (my-max1 7 6 *cf*)
7
[5]> (defparameter *ccf* (lambda (x y) (if (char> x y) t nil)))
*CCF*
[6]>  (my-max1 #\c #\b *ccf*)
#\c
[7]> (my-max1 #\c #\d *ccf*)
#\d

练习5.
(a) enigma函数的功能是找出list中是否有值为nil的元素，如果有，返回T；否则返回nil
(b) mystery函数的功能是返回x在y列表中的位置(下标)

练习6.
(a) x = car
(car (car (cdr '( a (b c) d ) ) ) )

(b) x = or
(or 13 (/ 1 0))
注：短路求值，后一项在13为t的情况下不被求值，避免了divide by 0错误

(c) x = apply

注意funcall与apply的区别
(funcall function arg1 arg2 …)
==  (apply function arg1 arg2 … nil)
==  (apply function (list arg1 arg2 …))

练习7.
(defun have-list-param-p (x)
  (let ((result nil))
    (dolist (obj x)
      (if (listp obj)
        (setf result t)))
    result))

[1]> (load "list_param.lisp")
;; Loading file list_param.lisp …
;; Loaded file list_param.lisp
T
[38]> (have-list-param-p '(1 2 3))
NIL
[39]> (have-list-param-p '(1 (2 3) 4))
T

练习8.
(a)
iterative solution:
(defun print_dots (number-of-dots)
  (do ((i 1 (+ i 1)))
    ((> i number-of-dots))
    (format t ".")))

recursive solution:
(defun print_dots (number-of-dots)
  (let  ((i number-of-dots))
     (if (> i 1)
        (print_dots (- number-of-dots 1)))
     (format t ".")))

练习9.
(a) 问题所在：remove返回一个新的lst，原来的lst如果包含nil，则+会提示nil is not a number
修改后：
(defun summit (lst)
  (setf lst (remove nil lst)) 
  (apply #'+ lst))

(b) 问题所在：导致无穷递归，提示Program stack overflow. RESET
修改后：
(defun summit (lst)
  (if lst (+ (or (car lst) 0) (summit (cdr lst))) 0))
     
Common Lisp与Haskell不同，Common Lisp并非纯函数式编程语言，其中包含了诸多命令式(imperative)的元素，这样对于习惯了命令式编程的初学者来说，在学习过程中就不会感觉到过于剧烈的思维跳跃了。

© 2011, bigwhite. 版权所有.

去年曾囫囵吞枣般的学习过Haskell，一门通用且庞大的纯函数式编程语言。在惊叹于Haskell如此与众不同且功能强大的同时，也为Haskell Monad那魔鬼般的蹩脚语法所苦恼，而Monad的引入就是为了隔离副作用，并让你可以利用些过程式命令式语言解决问题的范式。

原以为Common Lisp也是一门函数式编程语言，应该与Haskell很像，但在看了《ANSI Common Lisp》一书后的前几章后我才发现其实不是那么回事儿。Common Lisp设计初衷其实是一门支持多范式的通用语言。除了语法上更接近于函数式编程范式外，你完全可以用Common Lisp写出具有过程式特点的代码（而且看起来也很容易）。另外Common Lisp Object System(CLOS)还给你提供了OO范式的选择。与Haskell相比，对于我这个C程序员来讲，Common Lisp带来思维跳跃似乎更小些，更有利于后续的学习和使用。

与Haskell的强类型和静态类型（即使你不显式指出类型，Haskell也会根据一些上下文的clue推导出类型，如果它发现类有不匹配，那么编译期间就会报错）不同，Common Lisp是动态类型和弱类型的，当然你也可以显式声明类型，但这么做也仅有利于编译器对代码的速度优化，并不能阻止什么。如：
> (declaim (type fixnum count))
> NIL
> (format t count)
*** – EVAL: variable COUNT has no value
> (setf count "hello lisp")
> "hello lisp"
> (format t count)
> hello lisp
> NIL

看到了吧，即使我们显式声明了count为fixnum类型，我们依然可以用字符串为其赋值。

Lisp语法十分简单：万物皆在括号内，无论代码还是数据。Lisp一直因括号泛滥而被诟病，不过对于我来说还好，也许是因为在C语言中也没少使用括号的缘故吧。另外现在的编辑器都支持高亮括号匹配，这样只要你细心些，写代码时基本不会出现因括号不匹配导致的一些问题。

编程语言影响思维习惯，但思维的转变不是一蹴而就的，也就是说用惯了C、Python等语言后，再去学习类似Common Lisp这类语言的确有些困难。遇到某问题时，或多或少还会首先以过程式的思维去考虑。另外Common Lisp也确实不是一门“小语言”，和Haskell一样，Common Lisp也很庞大，这也使得这些语言的学习曲线陡增。
  
之前一直认为Lisp也是一门解释性的语言，类似Python采用解析器的方式执行，性能不会很快。后来经了解后才得知诸多编译器（如CLisp）都是将源代码编译为某种格式的字节中间码，这样不仅性能得到了提升，可移植性还得到了兼顾。当然Lisp性能与C比起来还是要差出至少一个数量级的。Common Lisp的编译器我装了两个：CLisp和SBCL，目前来看似乎后者的开发更活跃一些。我个人则更多地使用CLisp。

这里必须得承认的是Lisp语言的应用还是比较小众的，甚至很多程序员都没有听说过有Lisp这门语言的存在。在实际商业开发中更是很少见到用Lisp实现的系统，这方面Haskell也有着同样的”感受“。不过近几年Lisp各种方言大有回升之势，Lisper们需要是耐心和时间。如果要想了解如何利用Common Lisp进行一些实际系统的开发，那么你就不能放过Peter Seibel于2005年编写的《Practical Common Lisp》一书。后来出版的《Real World Haskell》想必也是学习Peter Seibel试图为Haskell开发者们找到一条实际应用之道吧。

但有关Common Lisp的入门书，我还是觉得Paul Graham的《Ansi Common Lisp》更适合，另外在这之前可以先拜读一下Paul Graham的文章"The Roots of Lisp"，这将对Lisp的学习大有裨益。

既然本文的主题为Hello，Common Lisp，那最后还是按学习新语言的惯例，在这里向大家展示一下用Common Lisp是如何编写Hello World的吧：

;; HelloWorld.lisp

(defun hello-world ()
  (format t "hello, world!"))

(hello-world)

© 2011, bigwhite. 版权所有.