Change to markdown style code

Author: smacs

elisp/01-hello-world.md

@@ -5,9 +5,9 @@ title: 一个 Hello World 例子
 
 自从 K&R 以来，hello world 程序历来都是程序语言教程的第一个例子。我也用一个 hello world 的例子来演示 emacs 里执行 elisp 的环境。下面就是这个语句：
 
-{% highlight cl %}
+``` cl
 (message "hello world")
-{% endhighlight %}
+```
 
 前面我没有说这个一个程序，这是因为，elisp 不好作为可执行方式来运行（当然也不是不可能），所有的 elisp 都是运行在 emacs 这个环境下。
 

elisp/02-elisp-basic.md

@@ -8,154 +8,173 @@ title: 基础知识
 ## 函数和变量 ##
 
 elisp 中定义一个函数是用这样的形式：
-{% highlight cl %}
+
+``` cl
 (defun function-name (arguments-list)
   "document string"
   body)
-{% endhighlight %}
+```
 
 比如：
-{% highlight cl %}
+
+``` cl
 (defun hello-world (name)
   "Say hello to user whose name is NAME."
   (message "Hello, %s" name))
-{% endhighlight %}
+```
 
 其中函数的文档字符串是可以省略的。但是建议为你的函数（除了最简单，不作为接口的）都加上文档字符串。这样将来别人使用你的扩展或者别人阅读你的代码或者自己进行维护都提供很大的方便。
 
 在 emacs 里，当光标处于一个函数名上时，可以用 `C-h f` 查看这个函数的文档。比如前面这个函数，在 `*Help*` 缓冲区里的文档是：
 
-    hello-world is a Lisp function.
-    (hello-world name)
-    
-    Say hello to user whose name is name.
+```
+hello-world is a Lisp function.
+(hello-world name)
+
+Say hello to user whose name is name.
+```
 
 如果你的函数是在文件中定义的。这个文档里还会给出一个链接能跳到定义的地方。
 
 要运行一个函数，最一般的方式是：
-{% highlight cl %}
+
+``` cl
 (function-name arguments-list)
-{% endhighlight %}
+```
 
 比如前面这个函数：
-{% highlight cl %}
+
+``` cl
 (hello-world "Emacser")                 ; => "Hello, Emacser"
-{% endhighlight %}
+```
 
 每个函数都有一个返回值。这个返回值一般是函数定义里的最后一个表达式的值。
 
 elisp 里的变量使用无需象 C 语言那样需要声明，你可以用 setq 直接对一个变量赋值。
-{% highlight cl %}
+
+``` cl
 (setq foo "I'm foo")                    ; => "I'm foo"
 (message foo)                           ; => "I'm foo"
-{% endhighlight %}
+```
 
 和函数一样，你可以用 C-h v 查看一个变量的文档。比如当光标在 foo 上时用 `C-h v` 时，文档是这样的：
 
-    foo's value is "I'm foo"
-    
+```
+foo's value is "I'm foo"
     
-    Documentation:
-    Not documented as a variable.
+Documentation:
+Not documented as a variable.
+```
 
 有一个特殊表达式（special form）`defvar`，它可以声明一个变量，一般的形式是：
-{% highlight cl %}
+
+``` cl
 (defvar variable-name value
   "document string")
-{% endhighlight %}
+```
 
 它与 `setq` 所不同的是，如果变量在声明之前，这个变量已经有一个值的话，用 `defvar` 声明的变量值不会改变成声明的那个值。另一个区别是 `defvar` 可以为变量提供文档字符串，当变量是在文件中定义的话，`C-h v` 后能给出变量定义的位置。比如：
-{% highlight cl %}
+
+``` cl
 (defvar foo "Did I have a value?"
   "A demo variable")                    ; => foo
 foo                                     ; => "I'm foo"
 (defvar bar "I'm bar"
   "A demo variable named \"bar\"")      ; => bar
 bar                                     ; => "I'm bar"
-{% endhighlight %}
+```
 
 用 `C-h v` 查看 foo 的文档，可以看到它已经变成：
 
-    foo's value is "I'm foo"
-    
+```
+foo's value is "I'm foo"
     
-    Documentation:
-    A demo variable
+Documentation:
+A demo variable
+```
 
 由于 elisp 中函数是全局的，变量也很容易成为全局变量（因为全局变量和局部变量的赋值都是使用 `setq` 函数），名字不互相冲突是很关键的。所以除了为你的函数和变量选择一个合适的前缀之外，用 `C-h f` 和 `C-h v` 查看一下函数名和变量名有没有已经被使用过是很关键的。
 
 ## 局部作用域的变量 ##
 
 如果没有局部作用域的变量，都使用全局变量，函数会相当难写。elisp 里可以用 let 和 `let*` 进行局部变量的绑定。`let` 使用的形式是：
-{% highlight cl %}
+
+``` cl
 (let (bindings)
   body)
-{% endhighlight %}
+```
 
 bingdings 可以是 (var value) 这样对 var 赋初始值的形式，或者用 var 声明一个初始值为 `nil` 的变量。比如：
-{% highlight cl %}
+
+``` cl
 (defun circle-area (radix)
   (let ((pi 3.1415926)
         area)
     (setq area (* pi radix radix))
     (message "直径为 %.2f 的圆面积是 %.2f" radix area)))
 (circle-area 3)
-{% endhighlight %}
+```
 
 `C-h v` 查看 area 和 pi 应该没有这两个变量。
 
 `let*` 和 `let` 的使用形式完全相同，唯一的区别是在 `let*` 声明中就能使用前面声明的变量，比如：
-{% highlight cl %}
+
+``` cl
 (defun circle-area (radix)
   (let* ((pi 3.1415926)
          (area (* pi radix radix)))
     (message "直径为 %.2f 的圆面积是 %.2f" radix area)))
-{% endhighlight %}
+```
 
 ## lambda 表达式 ##
 
 可能你久闻 lambda 表达式的大名了。其实依我的理解，lambda 表达式相当于其它语言中的匿名函数。比如 perl 里的匿名函数。它的形式和 `defun` 是完全一样的：
 
-{% highlight cl %}
+``` cl
 (lambda (arguments-list)
   "documentation string"
   body)
-{% endhighlight %}
+```
 
 调用 lambda 方法如下：
-{% highlight cl %}
+
+``` cl
 (funcall (lambda (name)
            (message "Hello, %s!" name)) "Emacser")
-{% endhighlight %}
+```
 
 你也可以把 lambda 表达式赋值给一个变量，然后用 `funcall` 调用：
-{% highlight cl %}
+
+``` cl
 (setq foo (lambda (name)
             (message "Hello, %s!" name)))
 (funcall foo "Emacser")                   ; => "Hello, Emacser!"
-{% endhighlight %}
+```
 
 lambda 表达式最常用的是作为参数传递给其它函数，比如 `mapc`。
 
 ## 控制结构 ##
 
 ### 顺序执行 ###
 一般来说程序都是按表达式顺序依次执行的。这在 `defun` 等特殊环境中是自动进行的。但是一般情况下都不是这样的。比如你无法用 `eval-last-sexp` 同时执行两个表达式，在 if 表达式中的条件为真时执行的部分也只能运行一个表达式。这时就需要用 `progn` 这个特殊表达式。它的使用形式如下：
-{% highlight cl %}
+
+``` cl
 (progn A B C ...)
-{% endhighlight %}
+```
 
 它的作用就是让表达式 A, B, C 顺序执行。比如：
-{% highlight cl %}
+
+``` cl
 (progn
   (setq foo 3)
   (message "Square of %d is %d" foo (* foo foo)))
-{% endhighlight %}
+```
 
 ### 条件判断 ####
 
 elisp 有两个最基本的条件判断表达式 `if` 和 `cond`。使用形式分别如下：
-{% highlight cl %}
+
+``` cl
 (if condition
     then
   else)
@@ -164,10 +183,11 @@ elisp 有两个最基本的条件判断表达式 `if` 和 `cond`。使用形式
       (case2 do-when-case2)
       ...
       (t do-when-none-meet))
-{% endhighlight %}
+```
 
 使用的例子如下：
-{% highlight cl %}
+
+``` cl
 (defun my-max (a b)
   (if (> a b)
       a b))
@@ -179,34 +199,36 @@ elisp 有两个最基本的条件判断表达式 `if` 和 `cond`。使用形式
         (t (+ (fib (- n 1))
                  (fib (- n 2))))))
 (fib 10)                                ; => 55
-{% endhighlight %}
+```
 
 还有两个宏 `when` 和 `unless`，从它们的名字也就能知道它们是作什么用的。使用这两个宏的好处是使代码可读性提高，`when` 能省去 `if` 里的 `progn` 结构，`unless` 省去条件为真子句需要的的 `nil` 表达式。
 
 ### 循环 ###
 
 循环使用的是 `while` 表达式。它的形式是：
-{% highlight cl %}
+
+``` cl
 (while condition
   body)
-{% endhighlight %}
+```
 
 比如：
-{% highlight cl %}
+
+``` cl
 (defun factorial (n)
   (let ((res 1))
     (while (> n 1)
       (setq res (* res n)
             n (- n 1)))
     res))
 (factorial 10)                          ; => 3628800
-{% endhighlight %}
+```
 
 ## 逻辑运算 ##
 
 条件的逻辑运算和其它语言都是很类似的，使用 `and`、`or`、`not`。`and` 和 `or` 也同样具有短路性质。很多人喜欢在表达式短时，用 `and` 代替 `when`，`or` 代替 `unless`。当然这时一般不关心它们的返回值，而是在于表达式其它子句的副作用。比如 `or` 经常用于设置函数的缺省值，而 `and` 常用于参数检查：
 
-{% highlight cl %}
+``` cl
 (defun hello-world (&optional name)
   (or name (setq name "Emacser"))
   (message "Hello, %s" name))           ; => hello-world
@@ -218,10 +240,11 @@ elisp 有两个最基本的条件判断表达式 `if` 和 `cond`。使用形式
        (= (/ n (sqrt n)) (sqrt n))))
 (square-number-p -1)                    ; => nil
 (square-number-p 25)                    ; => t
-{% endhighlight %}
+```
 
 ## 函数列表 ##
-{% highlight cl %}
+
+``` cl
 (defun NAME ARGLIST [DOCSTRING] BODY...)
 (defvar SYMBOL &optional INITVALUE DOCSTRING)
 (setq SYM VAL SYM VAL ...)
@@ -237,6 +260,6 @@ elisp 有两个最基本的条件判断表达式 `if` 和 `cond`。使用形式
 (or CONDITIONS ...)
 (and CONDITIONS ...)
 (not OBJECT)
-{% endhighlight %}
+```