博客园_除却巫山不是云

Clojure程序员的Monad之旅（Part 4）

2012-03-20T05:32:00Z

翻译自 A Monad Tutorial For Clojure Programmers (Part 4)

在本次旅程的最后一节，我将会介绍monad transformer。我只介绍其中的一种，然后我会介绍probability monad 以及如何使用monad transformer来扩展它。

简单来说，monad transformer是一个函数，参数是一个monad，返回值也是一个monad。返回的monad是通过给传入的monad增加一些功能而产生的变形。这些增加的功能，是由monad transformer定义的。许多我前面提到的普通的monad，都有monad transformer 模拟，可以增加功能，使他们成为其它的monad。

考虑一下我们前面讨论过的maybe monad和sequence monad。maybe monad用来对可能失败的运行返回有效的值nil。sequence monad 用来对运算返回多值的结果，monad值组成的序列。把这个两个monad组合成一个新的monad，可以有2种形式：1）返回多值结果，值nil表示运算失败；2）或者返回多值结果，或者在失败的情况下返回nil。形式1）是比较有用的，对于形式2）来说实用价值不大，运算失败只要返回空序列的方式更简便。

那么，我们用什么办法把maybe monad和sequence monad组合起来，以便用现有的功能来实现我们所需的功能呢？很遗憾，这是做不到的。但是，我们可以保持一个monad不变，而把另一个改写成一个monad transformer。使用这个monad transformer来处理sequence monad（或其他的monad）来获得我们想要的结果。为了实现需要组合，我们就可以把maybe monad转换成一个 monad transformer，然后把他应用到sequence monad。

首先，看一下这两个monad的定义：

1 (defmonad maybe-m
2    [m-zero   nil
3     m-result (fn [v] v)
4     m-bind   (fn [mv f]
5                (if (nil? mv) nil (f mv)))
6     m-plus   (fn [& mvs]
7                (first (drop-while nil? mvs)))
8     ])
9
10 (defmonad sequence-m
11    [m-result (fn [v]
12                (list v))
13     m-bind   (fn [mv f]
14                (apply concat (map f mv)))
15     m-zero   (list)
16     m-plus   (fn [& mvs]
17                (apply concat mvs))
18     ])

然后看一下maybe monad transformer的定义：

1 (defn maybe-t
2   [m]
3   (monad [m-result (with-monad m m-result)
4           m-bind   (with-monad m
5                      (fn [mv f]
6                        (m-bind mv
7                                (fn [x]
8                                  (if (nil? x)
9                                    (m-result nil)
10                                    (f x))))))
11           m-zero   (with-monad m m-zero)
12           m-plus   (with-monad m m-plus)
13           ]))

在clojure.contrib.monads库中真正的定义，比这个要复杂一些，我稍后会解释，但我们现在的版本，已经够不错了。组合后的monad这样定义

1 (def maybe-in-sequence-m (maybe-t sequence-m))

直接调用这个函数，返回一个monad。让我们看看m-result的作用，maybe-m的m-result函数是identity，因此sequence-m的m-result函数，就是我们需要的m-result。事实正是如此，（with-monad m m-result）返回m的m-result函数。同样的结构，我们在m-zero和m-plus中也看到了，这说明，我们要修改的仅仅是m-bind部分。

组合后的m-bind抵用了sequence-m的m-bind函数，但是修改了参数，使用一个函数来表示其余的运算。在调用之前，首先检查参数是否为nil。如果为nil，就调用原先的函数，这样组合后的monad同基础monad一样，不需要计算，返回nil。尽管如此，我们不能只是返回nil，我们必须返回一个有效的monad值（在我们的例子中是返回序列中的nil元素）。因此，我们把nil传回给基础monad的m-result，由它来把nil包装到最终所需的结果中。

让我们看看实际的情况：

(domonad maybe-in-sequence-m
  [x [1 2 nil 4]
   y [10 nil 30 40]]
  (+ x y))

输出结果是：

(11 nil 31 41 12 nil 32 42 nil 14 nil 34 44)

正如我们期望的，所有的非nil值计算后都正常，但是第一眼看到这个结果我们有些惊讶，为什么是4个nil而不是8个呢（每个输入序列中的nil和分别另外一个序列的4个元素相加）？

为了理解这个原因，我们来看一下maybe-t中的m-bind函数，在顶层，使用[1 2 nil 4]作为monad值来运算。他把这个结构传给sequence-m的的m-bind函数，这个匿名函数总共调用了maybe-t的m-bind函数4次（每个元素1次）。对于其中3个非nil的值只是普通的+运算；对于nil值，结果直接返回nil，不进行运算。这样，第一个输入vector中的nil元素，在结果中产生了一个nil值，剩余的运算部分只执行了3次。这3次运算，每次又产生了3个有效的值和1个nil，这样从第二个输入vector，我们就得到了3 x 3 = 9个有效值，和3 x 1 = 3个nil，加上从第一个输入vector得到的一个ni，一共是9个值和4个nil。

用什么办法可以获得全部的 4 x 4共计16个运算值吗？当然，但是不能使用maybe-t。你只能分别使用maybe-m和sequence-m来计算：

1 (with-monad maybe-m
2   (def maybe-+ (m-lift 2 +)))
3
4 (domonad sequence-m
5   [x [1 2 nil 4]
6    y [10 nil 30 40]]
7   (maybe-+ x y))

如果你使用maybe-t，你总是会被短路逻辑影响：一旦有一个nil，就返回nil，并不继续进行剩余的计算。大多数情况下，这符合我们的需要。

maybe-t和sequence-m的组合并没有多少实用价值，因为一个更简单有效的方法是在计算前把非有效的参数从输入序列中移出。但是这个例子很简单，又能很好的解释原理。现在我们准备挑战一个更有实际意义的例子：使用maybe-t和probability distribution monad。

probability distribution monad用来处理有限概率分布，比如，在一个有限元素组成的集合里有非0值的概率。这个概率用一个map来表示，分别是值和它们出现的记录。有限分布相关的函数和monad在clojure.contrib.probabilities.finite-distributions库中。

巫云@：
由于目前clojure.contrib.probabilities.finite-distributions的代码跟clojure 1.3.0以上版本不兼容，这里我是使用clojure 1.2.0进行测试的。
使用leiningen的同学可以参考我的文章《64位window7下配置Clojure+Emacs开发环境》进行配置。关于出现这个问题的原因可参照这篇文章。

有限分布的一个简单例子：

(use 'clojure.contrib.probabilities.finite-distributions)
(def die (uniform #{1 2 3 4 5 6}))
(prob odd? die)

输出1/2，这是扔骰子点数出现偶数的概率。die的值，是扔骰子使出现的点数及其概率的分布情况：

{6 1/6, 5 1/6, 4 1/6, 3 1/6, 2 1/6, 1 1/6}

假设我们扔2次骰子，然后观察两次点数的和。他们的概率分布是怎样的呢？

(domonad dist-m
  [d1 die
   d2 die]
  (+ d1 d2))

结果是：

{2 1/36, 3 1/18, 4 1/12, 5 1/9, 6 5/36, 7 1/6, 8 5/36, 9 1/9, 10 1/12, 11 1/18, 12 1/36}

我们来看一下domonad块的内容：第一次的分布die绑定到d1，第二次的分布die绑定到d2，然后计算d1+d2的分布。这个例子很简单，概括来说，每次分布情况取决于上一次分布情况，这样就创建了变量的联合分布。这个方法被称为“原始取样”。

dist-m这个monad使用组合概率的基本原则：如果事件A发生的概率是p，事件B发生的概率是q，并且二者是相互独立的（至少互不影响），那么A和B同事发生的概率为 p x q。看dist-m的定义：

1 (defmonad dist-m
2   [m-result (fn [v] {v 1})
3    m-bind   (fn [mv f]
4               (letfn [(add-prob [dist [x p]]
5                         (assoc dist x (+ (get dist x 0) p)))]
6                 (reduce add-prob {}
7                        (for [[x p] mv  [y q] (f x)]
8                          [y (* q p)]))))
9    ])

像往常一样，m-bind中发生了有趣的事情。第一个参数mv是一个map，里面存放概率分布情况；第二个参数f是一个函数，代表剩余的运算，对于每个for里面的概率值，调用这个函数。for表达式同时遍历输入分布里的概率和（f x）返回的概率分布里的概率，通过乘法操作计算联合概率，并把结果输出到输出分布。通过对辅助函数add-prob上使用reduce来完成运算。add-prob的检查当前的map的值是否存在，如果存在，更新概率为add后的新值。这是必须的，因为在（f x）的取样过程中，同一个值如果对应不同的x，则可能被包含多次。（巫云@：比如 1+ 2 = 3， 2 + 1 = 3，3可能出现多次）

（巫云@：比如 1+ 2 = 3，2 + 1 = 3<，3可能出现多次）

再看一个更有趣的例子，著名的Monty Hall问题。在一个电视现场游戏中，玩家面对3扇门，其中只有一个门后面有奖品。如果玩家选择了正确的门就能得到奖品。说到这里，这个问题就可以简化为，获奖概率是1/3。

（巫云@：这个游戏也是来自一款电视节目，貌似跟砸蛋很像啊~）

但是这里有个小插曲，在玩家做出选择之后，主持人打开剩余2扇门中的1扇，这扇门后面是没有奖品的。然后主持人问玩家是否变更原先的选择。这真是个不错策略，是吧。

为了更好的定义这个问题，我们假设主持人是知道奖品位置的，因此他不会开打有奖品的门。然后我们开始编程：

1 (def doors #{:A :B :C})
2
3 (domonad dist-m
4   [prize  (uniform doors)
5    choice (uniform doors)]
6   (if (= choice prize) :win :loose))

一步步的看，首先，我们从A，B，C三个门中选择一个作为作为放奖品的门，这代表玩家开始游戏前的前奏。然后玩家开始选择。最后我们公布结果，输出:win或者:loose。很明显概率情况毫无异议，{:win 1/3, :loose 2/3}。

这覆盖了玩家不听取主持人建议的情况，如果他接受了主持人的建议，情况变得更加复杂：

(domonad dist-m
  [prize  (uniform doors)
   choice (uniform doors)
   opened (uniform (disj doors prize choice))
   choice (uniform (disj doors opened choice))]
  (if (= choice prize) :win :loose))

第3步变得最为有趣：主持人打开一扇未被选择的，并且没有奖品的门。我们的模型用移除奖品门和被选择门来体现这一步骤，从结果集合中我们可以看到，结果中包含1个或2个元素，取决于被选择门和奖品门。然后玩家改变他的选择，转而选择留下的那个门。在标准的3个门游戏中，这个可选集合里只有1个门，但是上面的代码适合更多门的情况。大家可以自己尝试一下。

执行的结果是{:loose 1/3, :win 2/3}，说明改变自己的选择是一个更佳的策略。

回到maybe-t，在有限分布库中定义了一个monad：

(def cond-dist-m (maybe-t dist-m))

这使nil成为一个特殊值，表达那些我们不想考虑的可能情况。使用maybe-t和dist-m，你能猜到在分布联合时nil是如何传递的：对于任何的nil值，任何对它有潜在依赖的分布都不被计算，并且nil值的概率被整个传递给输出结果中ni的概括。但是nil是如何进入到分布中的呢？并且这样做有什么好处呢？l

考虑最后这个问题，分布中引入nil的作用，是为了消除特定的值。一旦得到最终的分布情况，nil值会被移除，并且剩余的分布不会产生异常，他们的概率只和为1。移除nil以及消除异常的操作通过函数normalize-cond来完成。cond-dist-m是一个计算条件概率的经典方法，并常常用于辅助贝叶斯推理（各种数据分析中使用的重要技术）。

第一个练习，我们根据输入的分布和断言，来计算一个简单的条件概率。输出的分布只包含符合断言的值，但是概率分布的结果会被正常化：

1 (defn cond-prob [pred dist]
2   (normalize-cond (domonad cond-dist-m
3                     [v dist
4                      :when (pred v)]
5                     v)))

关键的代码是:when语句，正如我在第一和第二节提到的那样。domonad表达式展开为：

1 (m-bind dist
2         (fn [v]
3           (if (pred v)
4             (m-result v)
5              m-zero)))

如果你前面仔细留心，你可能要抱怨：使用dist-m和maybe-t，cond-dist-m应该不需要m-zero。但是，我前面说过，这里使用的maybe-t是一个简化版，真正的maybe-t要检查参数monad是否有m-zero，如果没有，用自己的m-zero函数(with-monad m (m-result nil))来代替它。因此cond-dist-m的m-zero是{nil 1}, 这个分布的唯一值就是nil

domonad在这里起的唯一作用就是保持所有符合断言的值的概率保持不变。调用normalize-cond去除nil，并用有效值的概率重建分布结果：

(cond-prob odd? die)

-> {5 1/3, 3 1/3, 1 1/3}

cond-dist-m在解决贝叶斯推理时变得太有趣了。贝叶斯推理是一项描绘不完全观察推论的技术。有广阔的应用领域，从垃圾邮件过滤到天气预报。关于这个推论的数学基础可以查看wiki。

这里我们要讨论一个很简单的推理问题和它在Clojure中的解决方案。假设你有2个骰子，第一个6个面，第二个8个面，第三个12个面。一个人拿起一个骰子，投几次，然后告诉点数，但并不告诉我们用的是哪个骰子。根据现象，我们来计算每个骰子被选中的可能性。我们定义一个函数，返回拥有n个面的骰子的点数分布概率：

1 (defn die-n [n] (uniform (range 1 (inc n))))

接下来，我们参考贝叶斯推理的核心知识。中心要素是考虑使用过的骰子扔出的点数的分布情况。我们需要每个骰子的概率分布：

1 (def dice {:six     (die-n 6)
2            :eight   (die-n 8 )
3            :twelve  (die-n 12)})

另外一个中心要素是体现选择骰子选取优先顺序的分布概率。我们对此没有定义，每个骰子被使用的概率是完全一样的：

1 (def prior (uniform (keys dice)))

现在我们开始写推理函数。参数是选取的优先分布和观察的点数，返回一个综合了优先顺序和点数信息的归纳分布。

1 (defn add-observation [prior observation]
2   (normalize-cond
3     (domonad cond-dist-m
4       [die    prior
5        number (get dice die)
6        :when  (= number observation)]
7       die)))

看一下domonad，第一步根据优先级选取骰子；第二步，扔骰子获得一个点数；第三步，去除不在观察范围内的点数；最后返回die的分布。

建议把这个函数和贝叶斯定理进行比较。贝叶斯定理P(H|E) = P(E|H) P(H) / P(E), 其中H表示假设（hypothesis，假设选择了X骰子），E表示事实（evidence，观察的现象是扔出的点数N）。P(H)是优先序列。这个公式必须在确定的值E上使用。

domonad第一行实现了P(H)，第二行实现了P(E|H)。这两行合在一起就是一个我们前面提到的P(E, H)原始取样。:when代表了观察现象；我们希望把贝叶斯定理使用到确定的值E。一旦E确定了，P(E)就是一个数字。最后normalize-cond对它进行正常化。

让我们看一下在观察到1的情况下是什么结果：

1 (add-observation prior 1)

-> {:twelve 2/9, :eight 1/3, :six 4/9}

我们看到概率最高的的:six，其次是:eight，最小的是:twelve。这是因为，1在3个骰子上都存在，但是它在6个面的骰子上，出现概率是1/6，在8面和12面上的概率自然是1/8和1/12。这次观察的结果倾向于面较少的骰子。

如果我们观察3次，我们可以重复调用add-observation函数：

1 (-> prior (add-observation 1)
2 (add-observation 3)
3 (add-observation 7))

-> {:twelve 8/35, :eight 27/35}

现在我们看到:six消失了，因为观察到了7；接下来，:eight比:twelve得到了更多的青睐，也进一步验证了面较少的骰子，被选中的可能性较大。

这个定理在解决垃圾邮件过滤问题时的情况类似。在这个情况下，3个骰子被替换成选项:spam和:no-spam。对每一个选项，我们通过分析邮件正文得到一个词的分布概率。add-observation除了变量名函数完全相同。当我们对每一个想要分析的词进行评估的时候，可以根据数据库存储的对它的:spam和:no-spam的选择次数，算出一个优先顺序分布。

在介绍monad transformers内容的最后，我来解释一下maybe-t的m-zero问题。正如你知道的，mabye-m有一个m-zero函数(nil)和一个m-plus的定义，它们在被maybe-t使用时是可以被移除的。这就是为什么看到cond-dist-m要那么做的原因。尽管如此，就像sequence-m一样，基础的monad可以拥有自己的m-zero和m-plus。那么组合的monad应该定义那些内容呢？只有maybe-t的作者才能做出决定，所以maybe-t在这里有一个可选参数（看相关文档）。我们唯一可以明确的一点是，当一个基础的monad不包含m-zero和m-plus的时候，maybe-t肯定不会对它造成影响。

巫云@：
最后，偶再扼要总结一下这个系列讲到的monad的基本知识点：
1. monad是一种函数式编程常用的方法，把依赖前一步运算结果的多步运算组成一个运算。
2. monad定义中包括m-result，m-bind，m-zero和m-plus。其中m-result和m-bind是必须定义的：
m-result把每一个运算的结果包装后传递给m-bind剩余的执行步骤；m-bind根据绑定表达式把多步操作组成一个链。
3. domonad宏可以简化代码，它展开后成为一个(with monad ...)的block，包含m-bind，m-result等组成的运算结构。
4. 通过monad transformer可以把一个monad进行功能修改，变成另一个monad。
5. 一些常用的monad：identity-m, maybe-m, sequence-m, state-m, dist-m等。

好了，这个系列的4篇文章翻译完了。虽然内容包含许多函数编程和数学知识，不是很容易理解，但是如果大家仔细读过，也一定会有所收获的，感谢大家的支持！

本文链接

Clojure程序员的Monad之旅（Part 3）

2012-03-18T10:44:00Z

翻译自 A Monad Tutorial For Clojure Programmers (Part 3)

在开始monad高级话题之前，我们简单回顾一下monad的定义（参考Part 1和Part 2）：

1. 一种数据结构，表现运算的结果，或者运算本身。

2. 使用m-result函数，把一般的值，转换成等价的monad数据结构。

3. 使用m-bind函数，绑定一个使用monad数据结构表示的运算的值到一个名称（使用接受一个参数的函数），使这个值在接下来的运算中可用。

以sequence monad为例，数据结构为sequence，表示最终结果非唯一的运算；m-result是list函数，把每次运算结果转换成一个序列，序列的元素是运算的每个值转成的list；m-bind函数继续对序列进行处理，并把结果移出list嵌套。

以上3个要素定义了一个monad，有些monad除了这些必要条件外，还增加了2个额外的定义，以实现特殊功能。这两个函数就是m-zero和m-plus。m-zero代表一个特殊的monad值，表示当一个运算没有返回值时的返回结果。例如：maybe monad中的nil，通常代表了计算过程失败。另一个例子是sequence monad中的空序列。identity monad 则是不包括m-zero的例子。

m-plus函数把多个计算的结果合并成一个。对sequence monad来说，就是把多个sequence连接成一个；对maybe monad来说，就是返回参数列表中第一个不是nil的参数。

m-zero和m-plus需满足的条件：

(= (m-plus m-zero monadic-expression)

(m-plus monadic-expression m-zero)

monadic-expression)

一句话，就是组合m-zero和任意的monad表达式，必须返回等价的值。可以从maybe和sequence中验证这一点。

在monad中使用m-zero的好处之一就是可以使用条件分支。在Part1中，我们提及了:when表达式，现在我们就来讨论：

1 (for [a (range 5)
2 :when (odd? a)]
3 (* 2 a))

使用domonad来表示：

1 (domonad sequence
2   [a (range 5)
3    :when (odd? a)]
4   (* 2 a))

domonad宏把let形式的语法，转换成m-bind和m-result的组合式，a (range 5) 等价于

1 (m-bind (range 5) (fn [a] remaining-steps))

在remaining-steps中:when语句被特殊处理

1 (if predicate remaining-steps m-zero)

这个例子完全展开后就成为

1 (m-bind (range 5) (fn [a]
2 (if (odd? a) (m-result (* 2 a)) m-zero)))

把m-bind，m-result和m-zero的对应实现替换进来

1 (apply concat (map (fn [a]
2 (if (odd? a) (list (* 2 a)) (list))) (range 5)))

map的结果是包含1个或0个元素的list组成的序列：对于奇数的值，返回的是()，即m-zero的值，对于偶数，返回(结果)，即m-result的值。concat函数把这些list连接起来成为最后的结果。

对于m-plus，一般跟maybe monad和sequence monad一起使用。一个典型的应用是查找（比如一个语法解释器，一个正则搜索，一个数据库查询），可能成功（有返回结果）或失败（无返回结果）。m-plus用于把查找的结果组合返回（sequence monad），或者一直查找，直到找到一个符合条件的值（maybe monad）。原则上来说，使用m-zero比使用m-plus更合适，任何使用m-plus的地方，都可以用m-zero实现。

讲完理论，让我们熟悉几个monad。在本节的开头，我提到monad使用的数据结构并不总是表示运算步骤的结果，有时表示的是运算步骤本身。比如，state monad，它的数据结构是一个函数。

state monad的作用是把状态算法，用纯函数式的方式来实现。状态算法需要更新一些变量的值，在命令式语言中，这很普遍，但是却不符合纯函数式编程的基本原则，因为纯函数式语言是不允许可变数据结构的。一个解决方法是在纯函数语言中使用特殊的数据项（典型的就是Clojure的map）来存储算法所需的可变数据的当前值。在命令式编程中，一个函数可以通过传参，修改变量的当前值，并返回更新后的值。对状态的修改变成显式的数据项，在函数中传递。state monad可以隐藏状态传递的过程，并且写出的算法使用命令式风格来查询和修改状态。

state monad和我们之前看到的monad不同，他的数据结构是一个函数，即运算本身。state monad的值是一个接受一个参数的函数，这个函数就是当前状态的运算。并且返回一个vector，vector长度为2，包括计算结果和更新后的状态。实际上，这些函数都是典型的闭包，并且你在程序中使用的代码和函数，都产生这样的闭包。就像你看到的，state monad允许你组合这些函数，使你的程序看起来跟命令式的一样，尽管他们是纯函数式的。

让我们从一个简单的常见场景开始：你要处理的state以map形式存储。你可能认为map是一个命令式语言中的概念，每个key定义一个变量，两个基本的操作来读取和修改值。在Clojure的monad库中已经提供了这个功能，但不论如何，我这里还是要展示一下（巫云@：如果已经引入了clojure.algo.monads，会发生函数名冲突，可以改名后测试）

首先，我们看fetch-val函数，用于读取一个变量的值：

1 (defn fetch-val [key]
2 (fn [s]
3 [(key s) s]))

这里我们定义一个生成state monad值的函数（巫云@：原文为state-monad-value-generating function）。它返回一个状态变量s，当执行时，返回一个返回值和新状态组成的vector。返回值是state在map对应的key值。这个函数不改变状态，只是查找。

下面我们来看set-val，返回前一状态的值和包含新状态的map组成的vector：

1 (defn set-val [key val]
2   (fn [s]
3     (let [old-val (get s key)
4           new-s   (assoc s key val)]
5       [old-val new-s])))

使用这两个元素，我们开始进行组合。我们来定义一个声明，把一个变量的值复制到另一个变量，并返回被修改变量的原值：

1 (defn copy-val [from to]
2   (domonad state-m
3     [from-val   (fetch-val from)
4      old-to-val (set-val to from-val)]
5     old-to-val))

那么copy-val函数返回什么呢？一个state-monad值，即一个函数，接受一个参数，state变量s。执行时，返回变量的旧值，和拥有有新值的state的拷贝。让我们试一下：

1 (let [initial-state        {:a 1 :b 2}
2       computation          (copy-val :b :a)
3       [result final-state] (computation initial-state)]
4   final-state)

结果为{:a 2, :b 2}，正如我们期望的。但是这是如何发生的呢？为了理解state monad，我们需要看一看m-result和m-bind的定义。

m-result没有什么特别，它返回一个函数，根据s，返回s在map中的值v，以及未更新过的状态s：

1 (defn m-result [v] (fn [s] [v s]))

m-bind的实现比较有趣：

1 (defn m-bind [mv f]
2   (fn [s]
3     (let [[v ss] (mv s)]
4       ((f v) ss))))

显然，他返回一个以状态变量s为参数的函数，执行这个函数时，首先对s运行mv（m-bind操作链中绑定的第一个声明）。返回值解析到结果v和新的状态ss。第一步的结果v，被后面的操作f使用（跟我们看过的其他m-bind一样）。调用的结果返回另一个state-monad值，它也是一个接受状态变量参数的函数。当我们进入(fn [s] …)时，我们已经处于执行阶段，于是我们必须对状态ss调用这个函数。

（巫云：可以把(domonad state-m
[from-val (fetch-val from)
old-to-val (set-val to from-val)]
old-to-val) 展开来理解一下运行步骤。）

state monad是一个非常基础的monad之一，许多monad都是state monad的变形。通常一个这样的变形在m-bind中增加一下东西，来说明状态已经被处理。一个例子就是clojure.contrib.stream-utils里的stream monad。它的state描述了数据组成的流，m-bind函数除了state monad基本的工作外，还检测非法值以及end-of-stream的条件。

state monad中的一个变形由于使用非常频繁，以至于成为了一个标准monad，这就是writer monad。它的state是一个累加器（在clojure.contrib.accumulators中定义），运算可以通过write函数进行累加。这个名字来自一个特殊的应用程序：loggin，它在identiy monad（Clojure的let就是一个identiy monad）中进行了运算。假设你想增加一个运算协议，使用list或string来累加计算过程中的信息，只需要修改write monad对应的identity monad，然后在需要的地方调用write。

这里有一个抽象的例子：著名的Fibonacci函数的最直接（同时也是效率最低的）实现：

1 (defn fib [n]
2   (if (< n 2)
3     n
4     (let [n1 (dec n)
5           n2 (dec n1)]
6       (+ (fib n1) (fib n2)))))

我们来增加一个运算协议，以便看看，在整个计算过程中，发生了哪些调用。首先，我们重写这个例子，定义每一个计算步骤

1 (defn fib [n]
2   (if (< n 2)
3     n
4     (let [n1 (dec n)
5           n2 (dec n1)
6           f1 (fib n1)
7           f2 (fib n2)]
8       (+ f1 f2))))

接着，我们用domonad代替let，并使用带有一个vetor累加器的writer monad：

1 (require ['clojure.contrib.accumulators :as 'accu])
2
3 (with-monad (writer-m accu/empty-vector)
4   (defn fib-trace [n]
5     (if (< n 2)
6       (m-result n)
7       (domonad
8         [n1 (m-result (dec n))
9          n2 (m-result (dec n1))
10          f1 (fib-trace n1)
11          _  (write [n1 f1])
12          f2 (fib-trace n2)
13          _  (write [n2 f2])]
14         (+ f1 f2)))))

最后，我们运行 fib-trace查看结果：

(fib-trace 3)

=> [2 [[1 1] [0 0] [2 1] [1 1]]]

第一个元素，是fib运算执行的返回值2；第二个元素，是一个协议vector，包含每步递归调用的参数和结果。

如果当我们把write调用注释掉，并且把monad类型换成identity-m时，就会变成一个标准的，无协议的fib函数。请自己尝试。

巫云@：测试代码为
(with-monad identity-m
(defn fib-trace [n]
(if (< n 2)
(m-result n)
(domonad
[n1 (m-result (dec n))
n2 (m-result (dec n1))
f1 (fib-trace n1)
f2 (fib-trace n2)]
(+ f1 f2)))))

Part 4 将会展示：如何通过组合名为monad transformers的monad构建组件来定义我们自己的monad。在演示段落，我将解释probability monad，以及如何通过跟maybe-transformer的组合把它应用到贝叶斯（Bayesian）估算。

本文链接

Clojure程序员的Monad之旅（Part 2）

2012-03-17T05:19:00Z

翻译自 A Monad Tutorial For Clojure Programmers (Part 2)

在Part1中，我们已经学习了最基础的2个monad：identity monad和maybe monad。在本节中，我们继续介绍sequence monad，并联系m-result函数进行讲解。最后，我会演示示2个有用的monad泛操作符。

sequence monad（Haskell中与之对应的是list monad）是使用频率最高的monad之一。Clojure中也内建了这个monad，比如for。让我们看下面的例子：

1 (for [a (range 5)
2 b (range a)]
3 (* a b))

for和let在语法上很像，它们有相同的结构：一个由绑定表达式组成的list，每个绑定表达式可以使用前面表达式的符号；一个结果表达式，此表达式通常需使用前面的绑定。不同的是：let给每个符号绑定一个单值，for绑定的是一个序列。for必须绑定序列，返回结果也是序列。for可以配合条件表达式:when和:while使用。从monad的复合运算的观点来看，sequence的运算结果可以看作非单一性的，比如，运算结果不只一个的情况。

使用monad库，上面的循环可以写成：

1 (domonad sequence-m
2   [a (range 5)
3    b (range a)]
4   (* a b))

我们已经知道，domonad宏展开为一个m-bind的操作链，并结尾调用m-result函数。下面我们要讲解如何定义m-bind和m-result，来获得循环效果。

前面我们看到，m-bind调用一个代表剩余计算步骤的函数，参数是绑定值。为了的到循环效果，我们要重复调用这个函数。第一步我们构造一个这样的函数：

1 (defn m-bind-first-try [sequence function]
2   (map function sequence))
3
4 (m-bind-first-try (range 5)  (fn [a]
5   (m-bind-first-try (range a)  (fn [b]
6     (* a b)))))

结果为：(() (0) (0 2) (0 3 6) (0 4 8 12))，而for表达式的到的结果是 (0 0 2 0 3 6 0 4 8 12)。我们想要一个无嵌套的sequence，因为嵌套的层数跟调用m-bind的次数是相同的。既然m-bind引入一次嵌套，我们就要想办法去掉这次嵌套。这似乎可以用concat解决，那么我们再来试一下：

1 (defn m-bind-second-try [sequence function]
2   (apply concat (map function sequence)))
3
4 (m-bind-second-try (range 5)  (fn [a]
5   (m-bind-second-try (range a)  (fn [b]
6   (* a b)))))

这次更糟，我们得到了一个异常。

java.lang.IllegalArgumentException: Don't know how to create ISeq from: Integer

我们来思考一下! 每次m-bind引入一层嵌套，同时消除一次嵌套。调用函数的嵌套层数决定了结果的嵌套层数。我们最终结果的嵌套层数跟（* a b）相同，即没有嵌套。那么如果我们想在结果中实现1层嵌套，跟调用多少次m-bind无关，正确的办法是在最后一次计算引入嵌套：

1 (m-bind-second-try (range 5)  (fn [a]
2   (m-bind-second-try (range a)  (fn [b]
3     (list (* a b))))))

一切正常。我们的(fn [b] ...)始终返回一个单元素的list。内层的m-bind创建一个单元素的sequence，每个元素是b的一个值，由这些值组成一个无嵌套的list。外层的m-bind，创建的是a的值组成的list。每个m-bind的结果同样是一个无嵌套的list。这很好的表现了m-result在monad中的作用。Sequence monad的最终定义如下：

1 (defn m-bind [sequence function]
2   (apply concat (map function sequence)))
3
4 (defn m-result [value]
5   (list value))

m-result的作用是，当出现在monad绑定的右侧时返回一个值，把符号绑定到这个值。在定义monad时，m-bind和m-result必须满足这个条件。在Clojure代码中表现为：

(= (m-bind (m-result value) function)

(function value))

还有其它两个monad规则，其中一个是：

(= (m-bind monadic-expression m-result)

monadic-expression)

monadic-expression代表任何有效的monad表达式，例如一个sequence monad表达式。使用domonad宏可以更清楚的理解这个规则

(= (domonad

[x monadic-expression]

monadic-expression)

最后一个规则是

(= (m-bind (m-bind monadic-expression

function1)

function2)

(m-bind monadic-expression

(fn [x] (m-bind (function1 x)

function2))))

使用domonad表示

(= (domonad

[y (domonad

[x monadic-expression]

(function1 x))]

(function2 y))

(domonad

[x monadic-expression

y (m-result (function1 x))]

(function2 y)))

使用monad时不需要记住这些法则，除非你要创建自己的monad。你需要记住的是(m-result x)代表值为x的monad运算。我们前面讲过的identity monad和maybe monad，没有特别的monad表达式，此时m-result只是identity函数

现在放松一下。关于monad的理论我们下一节再讨论，那时我还会告诉你一些关于for中使用:when的事情。本节剩余部分主要是编程实践。

我们也许要问，既然Clojure已经有个let和for，为什么还要制造identity monad和sequence monad呢？答案就是在各种monad中有可共用的泛操作。使用monad库，你可以写一个函数，把monad作为参数，并在给定的monad中组合多个运算。我待会用一个抽象示例来演示。Monad库还包括许多可在任何monad中使用的操作，它们的名字都以“m-”开头。

使用最频繁的monad泛函数是m-lift，它把一个参数为n个值参数的函数，转换成一个参数为n个monad表达式，并且返回值也是monad表达式的函数。这个新函数隐式调用了m-bind和m-result。举个简单的例子：

1 (def nil-respecting-addition
2 (with-monad maybe-m
3 (m-lift 2 +)))

这个函数返回两个参数的和，类似+，区别是它在任何参数为nil的情况下都返回nil。记住，m-lift必须指定函数需要的参数个数，这个信息是无法从函数中获得的。

我们用domonad写出等效的表达式，以便看清m-lift的工作原理

1 (defn nil-respecting-addition
2   [x y]
3   (domonad maybe-m
4     [a x
5      b y]
6     (+ a b)))

看得出，m-lift对每个参数调用了一次m-result和m-bind。同样的定义，如果使用sequence monad，将会返回一个函数，这个函数返回一个求和的sequence，它的值是从两个输入的sequence中计算得来。

练习：下面的函数跟Clojure的哪个著名的内建函数等效呢？

(with-monad sequence-m
  (defn mystery
    [f xs]
      ((m-lift 1 f) xs )))

巫云@：从函数结构巫云认为这个好像是map嘛，我们来试一下
(mystery #(* 2 %) [1 2 3 4 5])

返回结果：(2 4 6 8 10)，果然跟map一样哦。

另一个常用的monad泛函数是m-seq，他接受一个monad 表达式组成的sequence，返回一个结果值的sequence。根据domonad的规则，（m-seq [a b c]）相当于

(domonad
  [x a
   y b
   z c]
  '(x y z))

使用m-seq的例子，请自己来试一下

1 (with-monad sequence-m
2 (defn ntuples [n xs]
3 (m-seq (replicate n xs))))

巫云@：我们来测试一下

(ntuples 1 [1 2 3]) => ((1) (2) (3))
(ntuples 2 [1 2 3]) => ((1 1) (1 2) (1 3) (2 1) (2 2) (2 3) (3 1) (3 2) (3 3))

因为使用了sequence-m，我们可以想象成这是n层的循环。

最后介绍m-chain，它接受一个单参数操作组成的list。然后把这些操作组成一个链，并使每个参数从操作链上流过。比如：（m-chain [a b c]）等价于

1 (fn [arg]
2   (domonad
3     [x (a arg)
4      y (b x)
5      z (c y)]
6     z))

一个常用的例子是层级结构的遍历。Clojure的parents函数通过使用multimethod，返回一个类的的所有基类和接口。下面的函数以parents为基础，寻找一个类的第n代祖先。

1 (with-monad sequence-m
2   (defn n-th-generation
3     [n cls]
4     ((m-chain (replicate n parents)) cls )))
5
6 (n-th-generation 0 (class []))
7 (n-th-generation 1 (class []))
8 (n-th-generation 2 (class []))

巫云@：这个例子相当于把n次parents操作组成了一个操作链

你可能发现了，有些类在结果中出现了不只一次，因为他们是很多类的基类。事实上，我们应该使用sets代替sequence来表现结果，这并不难，把sequence-m，替换成set-m即可。

在Part3，我会讲:when条件表达式在循环中的使用，并且看看他们在monad中是如何实现的，并且还会介绍其它几个monad。

本文链接

Clojure程序员的Monad之旅（Part 1）

2012-03-16T09:57:00Z

翻译自 A Monad Tutorial For Clojure Programmers (Part 1)

译者注，在一些Clojure同学的要求下，翻译了这个系列，虽然是09年的老文章了，但是讲解了FP的一些重要概念，不妨一读。

Monad在函数式编程中常常跟Haskell联系在一起。在Haskell中，他们在I/O等很多应用中扮演了核心角色。目前多数对monad的介绍都是为Haskell程序员编写的，尽管如此，monad可以在任何一种函数语言中使用，甚至某些语言跟Haskell想去甚远。这里，我要使用Clojure来解释monad的概念，Clojure是一种拥有强大函数编程支持的，时髦的lisp方言。

Clojure的库：clojure.contrib.monads实现了monad。

首先，在REPL中引入这个库

1 (use 'clojure.contrib.monads)

巫云@：clojure升级到1.3以后，monads的库被移出contrib，目前在clojure.algo.monads中，可从maven下载，用leiningen的同学参考我前面的文章《64位window7下配置Clojure+Emacs开发环境》：在project1.clj的:dependencies节，增加[org.clojure/algo.monads "0.1.0"]，重新运行lein deps，下载需要的库。引入库的代码也相应改成(use 'clojure.algo.monads)

Monad 用来把多个运算步骤组合成一个更大的多步运算。让我们来创建一个最简单的monad，这个monad在Haskell中被称为identiy monad。实际上Clojure语言已经内建了这个机制，而且你一定使用过，它就是let

看下面的代码：

(let [a 1

b (inc a)]

(* a b))

它可以被理解为一个3步运算：

1. 计算1（常量），结果叫做a

2. 计算(inc a),结果叫做b.

3. 计算(* a b),结果作为整个多步运算的结果

每一步都访问了前一个步骤运算结果绑定到的符号

现在假设 Clojure没有let表达式，我们可以使用什么办法来达到同样的效果呢？对，我们可以使用函数，下面的表达式实现了这个效果：

1 ( (fn [a] ( (fn [b] (* a b)) (inc a) ) ) 1 )

最外层参数为a的匿名函数，接受的参数是1，通过这种方式，我们把1 绑定到a。在这个函数内部，使用同样的结构，使参数为b的函数，调用（inc a）作为他的传入参数。可以在REPL中验证，结果与let形式的一致。

当然，我们不仅仅为let重新造个轮子。这个计算步骤看起来与表达的相反，而且整个结构难于理解。但是我们可以通过一个小的辅助函数bind，使运算顺序变成从右向左的。这里我们把他成为m-bind（monad的bind），这也是他在Clojure的monad库中的名字。首先，我们定义函数：（注，如果已经引入了monads库，会提示名称冲突，可以换个名字）

1 (defn m-bind [value function]

2 (function value))

正如你看到的，他的工作很简单，但是却令参数值在函数左边传入成为可能。使用m-bind，我们可以这样写：

1 (m-bind 1 (fn [a]

2 (m-bind (inc a) (fn [b]

3 (* a b)))))

现在，这个方式，还是不如let做的漂亮，但是我们已经离目标更近了。有一个宏可以把let转换成由m-bind组合成的一个操作链，这个宏就是domonad。现在我们可以这样写我们的例子：

1 (domonad identity-m

2 [a 1

3 b (inc a)]

4 (* a b))

现在这已经看起来跟let方式几乎没什么差异了，运行macroexpand-1把宏展开

1 (clojure.contrib.monads/with-monad identity-m

2 (m-bind 1 (fn [a] (m-bind (inc a) (fn [b] (m-result (* a b)))))))

通过结果我们看到，在一个(with-monad identity-m ...)定义的块中，通过m-bind组成了一个操作链，并调用m-result （后面解释）。对于identiy monad（indentiy-m）来说，m-result就是identiy-它的名字。

你可能已经猜到，monad是let的泛型化，通过把m-bind替换为其他函数，可以创造更多的功能。每个monad定义了对m-bind的实现，并实现对应的m-result。通过一个with-monad块，把这些实现绑定起来。这样，你就可以用一单个表达式来组合多个步骤。通常情况下，我们是用domonad宏，它可以帮助我们做这些事情

在第二个例子中，我们将看到另一个简单的monad，但是它能带给你在let中你没有发现的知识。假设，你的运算有时可能失败，这时要返回nil。我们来写这样一个函数：

1 (defn f [x]

2 (let [a x

3 b (inc a)]

4 (* a b)))

在一个可能失败的运算中，我们想在x为nil或者（inc a）产生nil的时候返回nil。当然了，（inc a）永远多不会返回nil，这里只是做个例子。无论如何，这个思想的中心就是当任何运算步骤产生的nil，最终结果就是nil，剩下的步骤将被取消。我们需要做出一些改动：

1 (defn f [x]

2 (domonad maybe-m

3 [a x

4 b (inc a)]

5 (* a b)))

这个maybe monad，代表着运算的结果可能是有效值，也可能是nil。他的m-result函数仍然是identiy，这里我们就略过对m-result的讨论（在第二部分中将详细介绍）。所有的神奇都在m-bind函数中：（注：每个不同的monad，差别就在于对m-bind和m-result的不同实现，这里可以看到identity-m和maybe-m的区别）

1 (defn m-bind [value function]

2 (if (nil? value)

3 nil

4 (function value)))

当value参数的值不是nil时，调用function函数，与indentiy monad做的工作一样。记住，这个函数的效果影响了所以的计算步骤。如果value为nil，那么m-bind返回nil，剩余的计算都不会被执行。当调用（f 1）返回的是2；当调用（f nil），返回nil，无需在每一步的计算中添加检测nil的代码，m-bind悄悄的为你做了这些事。

在part2中，我将介绍更多的monad，并且讨论一些在任何用于辅助组合运算的monad中都能使用的泛型函数。

关于monad，dict.cn解释为：单位，单一体，单细胞生物，一价原子
我的理解，在函数式语言中，monad指通过一种形式，把多个运行步骤组合在一起的方式

本文链接

关于Lisp的真相

2012-03-12T09:42:00Z

本文揭露 Lisp 的真相，并列出一些可选的替代品。

(转载自：http://blog.sina.com.cn/s/blog_54a7c4d201013irb.html )

学习 lisp 将改变你的人生。

你的脑袋会变得超出你想象得大。

你会把你所有的程序都用随便的几行重写。

社会将抛弃你，你也将抛弃社会。

你将会开始对身边的任何人和任何事不满。

Lisp 是这样的简单，以至于你可以只需要用几分钟来学习它。现在我就刚学会它，就在我等公车的时候。

Lisp 是这样的简单，以至于你可以用任何语言实现它，只需要简单的几页代码。然而这事基本不会发生，因为一旦你学会了 lisp 你就不会再想要用除 lisp 之外的任何语言写任何东西。所以你也就会对用 lisp 之外的其他语言来实现 lisp 感到厌烦。

Lisp 可以完全地用 lisp 来实现。我刚刚完整地用 lisp 实现了 lisp，就在我跳上一辆公车并买票的瞬间。

当你变成一个 lisper ，你会嘲笑所有的笑话，因为再没有什么人的想法会是有趣的。你会知道一些无法用普通命令式语言表达的东西。

当人们做些像跟你说“嗨，你好吗？”这样的事时，你会觉得他们都是白痴。因为一个 lisper 根本不需要使用这么具体的构造。 Lisp 抽象出交互当中的那些模式使它们完全不相关。跟一个 lisper 伙计打招呼的正确方式是只需要轻轻地点一下下巴，以及大约十分之一程度的眨左眼，然后指向你的锡纸帽。他们就会明白你的意思。如果他们不明白，那么他们就不是真正的 lisp 程序员，那么也就没什么关系。

Lisp 很久以前就被发明出来了，在 java 之前，在 C 之前，在 fortran 之前，在计算机之前，在人类之前，在地球被建立之前。宇宙本身就是一个 lisp 程序，这事一点也不重要，以至于没有一个真正的 lisper 愿意实现它。

Lisp 是如此的优雅以至于你只要接触它一丢丢点，就会让你好像取得了一个演出季的皇家芭蕾舞团舞者资格一样。你会穿着你的 tutu （芭蕾舞超短裙）跑出去到大庭广众面前，然后仅用你的脚尖在空气中画出一朵朵的圆括弧。

只有 lisper 能真正定义何为有趣。也许 ML 语言也能。今天所有的语言都基于 fortran 和 lisp。不好的部分来自 fortran ，好的来自 lisp。

如果你用 lisp 用得足够好，你会立刻对 lisp 感到失意。 Lisp 不是一个合格的 lisp 。这时我的公车开过了两个街区，我写了一些简单的 lisp 宏。它们非常强大，它们使得 lisp 完全过时了，它们作为一门新的语言替代了 lisp 。幸运的是，这门新的语言还是叫做 lisp 。而且我可以证明（从数学上证明），我刚创造的这个新的 lisp 从各种你能想到的方面都远比 lisp 好得多，而同时它又在各种你能想到的方面都等同于 lisp 。我对此很兴奋。同时又感到很乏味。

Reddit 证明了 lisp 确实很牛逼。 Paul Graham 最初是用 lisp 写的 reddit ，当时他正在餐桌旁等他的咖啡。 Reddit 是如此的牛逼，以至于它必须被用 python 重写，这样他才能被普通计算机理解。因为它是用 lisp 写成的，所以重写它并没有花费什么努力，重写工作在两个处理器周期之内就完成了。 Paul Graham 他本人就是完全由他本人的早期版本用 lisp 写成的。这个他本人的早期版本，也是用 lisp 写的，是由更更早版本的 lisp 操刀的。这就是 lisp, paul graham, lisp, paul graham, 无穷无尽。

因为我们达到了摩耳定律的极限，未来的计算机具有非常多核的处理器并且所有的程序都必须用 haskell 和 lisp 的组合来写。这组合太过牛逼，以至于这些未来的计算机要实现我们的任何想法，都必须创建时间旅行算法来跟更遥远的未来的其他计算机借用处理能力。这听上去很难，不过在 lisp 里却没什么。在 haskell 里这是一个内建特性，对于任何一个懂得 lisp 或者 haskell 的人来说实现它都只需要用很无脑的方式。

在那之后，未来的计算机将被称作 Lisputer 。它的速度将使用 Lispunit 来衡量。Lispunit 表示有多少关于 lisp 不足的争论可以同时被无穷数量的 lisp 专家提出和驳回并最终毫无结论。今天的计算机的运行低于一个 lispunit 。 Lisputer 运行会达到很多 Lispunit 。Lisp 将会是使用普通数字能表示的宇宙基础最大常量。可以充满自信地说：它的结尾会是无穷数量的右括号。

到此为止，我今天在公车上读了一篇关于 lisp 的文章。置顶文章。所有（其他）关于 lisp 的文章都真的太满了 —— 我的脑子开始冒出我的耳朵。这一篇： lisp is sin ，是 Sriram Krishnan 写的。文中他谈到了用 C# 来工作，用 Lisp 做兴趣爱好。他还谈到了一些从 C# 转向 lisp 的方法。

这里是一些那篇文章的评论里建议的有 lisp 瘾的人使用的替代品：

还有一个人建议移植 python 的库到 lisp 。

奇怪为啥没提到 Ruby （参考 Why Ruby is an acceptable lisp ，还有 steve yegge 的回应：'lisp is not an acceptable lisp' ）

（后记：第一个发评论说“ Paul Graham 没有写 reddit ” 的人应该奖一个棒棒糖。）

原文更精彩！

本文链接

64位window7下配置Clojure+Emacs开发环境

2012-02-20T09:25:00Z

为了学习Clojure，我最近特别在windows下配置了基于Emacs的Clojure开发环境。把过程做个记录，跟大家分享一下。过程不算太复杂，关键是要多使用Google来解决问题，有些版本问题比较难解决，耐心多尝试就能成功。很多同学都说使用linux更合适等等，我觉得确实有道理，但windows毕竟是很多程序员每天工作必用的工具，使用起来方便的多，所以还是有必要折腾一把。

开始了，首先我的操作系统是64位的windows7，英文版。随着现在内存的价格下降，64位win7系统已经开始成为程序员的主要工作平台，所以我们配置的开发环境也要能支持64位win7才算合格。

具体步骤：

1. 安装jdk，因为Clojure是基于JVM的语言，所以java开发环境肯定是必装的。我们直接下载Oracle官方的64位安装包，1.7的最新版本：jdk-7u2-windows-x64.exe。下载完毕后双击安装即可。

安装完毕，添加环境变量JAVA_HOME，内容为jdk的系统路径。

例如：

JAVA_HOME => D:\Program Files\Java\jdk1.7.0_02

PATH => D:\Program Files\Java\jdk1.7.0_02\bin

打开终端，测试，输入java –version回车

2. 安装maven2，maven是java开发常用的项目构建工具，提供jar包的管理功能，因为leiningen需要使用maven的软件仓库进行包的管理，因此，我们先要安装maven2。从官方下载压缩包，我下载的是2.2.1版

下载网站：http://maven.apache.org/download.html

下载完毕，解压到本地目录，我放置在D:\new\apache-maven-2

添加环境变量：各位同学请输入自己的路径

M2_HOME => D:\new\apache-maven-2

M2 => D:\new\apache-maven-2\bin

MAVEN_OPTS => -Xms256m -Xmx512m

PATH => %M2%

打开终端，测试，输入mvn --version回车

3. 安装leiningen，leiningen是基于Clojure的项目构建工具，可以为Clojure项目打包解决项目依赖，这也是我们这次配置中要使用的主要工具。

下载leiningen的windows压缩包和jar包（这里注意，不要用1.62的安装脚本安装，运行后面步骤时会出现错误），我下载的是：

leiningen-1.5.2-win.zip和leiningen-1.7.0-SNAPSHOT-standalone.jar

下载网站：https://github.com/technomancy/leiningen/downloads

下载完毕，leiningen-1.5.2-win.zip解压缩到本地目录。我放置在D:\new\lein，同时把leiningen-1.7.0-SNAPSHOT-standalone.jar拷贝到这个文件夹下面

添加环境变量：各位同学请输入自己的路径

Path => D:\new\lein

LEIN => D:\new\lein

LEIN_JAR => d:\new\lein\leiningen-1.7.0-SNAPSHOT-standalone.jar

打开终端，测试，输入 lein version回车

安装leiningen插件：

swank-clojure，用于Emacs的repl插件，集成了SLIME功能。使用命令

lein plugin install swank-clojure 1.4.0回车

lein会自动下载相关依赖并安装swank-clojure

至此，lein安装完毕

4. 安装Emacs，Emacs是一个多功能的文本编辑工具，可谓大名顶顶，是Hacker们的最爱。我们下载最新的Emacs2.4版。

下载地址：https://code.google.com/p/emacs-for-windows/updates/list

压缩包解压到本地路径。

安装Clojure插件clojure-mode

下载地址https://github.com/jochu/clojure-mode

只下clojure-mode.el即可，下载完毕放到Emacs的默认插件目录下面

在win7下，Emacs的默认插件目录是C:\Users\用户名\AppData\Roaming\.emacs.d\

由于AppData是隐藏文件，要注意。我放置的路径是C:\Users\Adam\AppData\Roaming\.emacs.d\clojure-mode\clojure-mode.el

Emacs的默认配置文件夹是C:\Users\用户名\AppData\Roaming，配置文件名是.emacs。如果文件不存在，可以手动创建一个。

编辑.emacs文件，添加如下内容：

(add-to-list 'load-path "~/.emacs.d")

(add-to-list 'load-path "~/.emacs.d/clojure-mode")

(require 'clojure-mode)

其他插件可选择性的安装，关于Emacs插件的安装和配置，这里就不多讲了，大家多Google即可。记住一点，开源东西bug不少，版本兼容性差，大家一定要耐得住性子才能成功啊。坚持，再坚持，哈哈，痛苦的过程。

推荐安装的插件：auto-complete, paredit,color-theme

全部的配置如下:

1 (add-to-list 'load-path "~/.emacs.d")
2 (add-to-list 'load-path "~/.emacs.d/clojure-mode")
3 (add-to-list 'load-path "~/.emacs.d/color-theme")
4 (add-to-list 'load-path "~/.emacs.d/auto-complete")
5
6 (require 'clojure-mode)
7
8 (require 'color-theme)
9 (color-theme-initialize)
10 (color-theme-xemacs)
11
12 (require 'auto-complete-config)
13 (ac-config-default)
14 (add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/dict")
15
16 (autoload 'paredit-mode "paredit"
17       "Minor mode for pseudo-structurally editing Lisp code." t)
18     (add-hook 'emacs-lisp-mode-hook       (lambda () (paredit-mode +1)))
19     (add-hook 'lisp-mode-hook             (lambda () (paredit-mode +1)))
20     (add-hook 'lisp-interaction-mode-hook (lambda () (paredit-mode +1)))
21     (add-hook 'scheme-mode-hook           (lambda () (paredit-mode +1)))
22     (add-hook 'clojure-mode-hook           (lambda () (paredit-mode +1)))
23     (add-hook 'slime-repl-mode-hook (lambda () (paredit-mode +1)))
24 (defun override-slime-repl-bindings-with-paredit ()
25             (define-key slime-repl-mode-map
26                 (read-kbd-macro paredit-backward-delete-key) nil))
27                 (add-hook 'slime-repl-mode-hook 'override-slime-repl-bindings-with-paredit)
28
29 (custom-set-variables
30  ;; custom-set-variables was added by Custom.
31  ;; If you edit it by hand, you could mess it up, so be careful.
32  ;; Your init file should contain only one such instance.
33  ;; If there is more than one, they won't work right.
34  '(tool-bar-mode nil))
35 (custom-set-faces
36  ;; custom-set-faces was added by Custom.
37  ;; If you edit it by hand, you could mess it up, so be careful.
38  ;; Your init file should contain only one such instance.
39  ;; If there is more than one, they won't work right.
40  '(default ((t (:inherit nil :stipple nil :background "gray80" :foreground "black" :inverse-video nil :box nil :strike-through nil :overline nil :underline nil :slant normal :weight normal :height 113 :width normal :foundry "outline" :family "Consolas")))))
41
42 (show-paren-mode 1)
43 (setq visible-bell nil)
44 (setq scroll-step 1
45         scroll-margin 3
46         scroll-conservatively 10000)
47 (global-linum-mode 'linum-mode) ;
48 (set-scroll-bar-mode nil) ;去掉滚动条
49 (auto-save-mode nil) ;;禁止自动保存
50 (global-set-key (kbd "C-|") 'other-window);
51 (setq frame-title-format
52       '("%S" (buffer-file-name "%f"
53                    (dired-directory dired-directory "%b"))))

5. 好了，安装完毕，经过一大堆的配置，现在我们要开始享受劳动成果了。

1）新建一个文件夹，我用的是D:\new\ClojCodes\

2）进入终端，输入以下命令：

cd d: 回车

cd new\ClojCodes\ 回车

lein new Project1回车

3）这时，会创建一个D:\new\ClojCodes\ Project1的项目文件夹

我们打开这个文件下的project1.clj把内容修改为：

1 (defproject SwankProject "1.0.0-SNAPSHOT"
2   :description "FIXME: write description"
3   :dependencies [[org.clojure/clojure "1.3.0"]
4                  [org.clojure/clojure-contrib "1.2.0"]])

保存。

4）终端下进入这个文件夹，输入

lein deps回车

lein将通过maven的仓库管理，自动下载依赖的jar包并更新

可能需要较长时间的等待，请耐心。

5）启动Emacs，打开我们修改过的project1.clj，按下alt+x，Emacs的表示法为M-x，在提示处输入clojure-jack-in，稍候片刻，就会出现slime的repl界面，然后我们可以输入简单的clojure代码进行测试和编程了。

文章结束，祝大家玩的开心。

最后的截图：

本文链接

开张第一日

2006-08-08T01:56:00Z

今天终于决心来这里安家了，终于有机会和各位CNBLOGS上的高手一起切磋了，心里那个高兴啊，哈哈哈哈哈哈... ... 其实小弟水平很菜的，做了2年的Delphi＋SQL Server，对于.Net还不是很熟，各位高手有什么经验一定要好好指导我啊！我目前对Asp.net的Web 控件开发很感兴趣，希望有这方面经验的朋友给我留言指导，感激涕零啊！留下我的MSN：wizzard_cloud@...