clojure从零开始（五）
1. Pulling It All Together
用以前的各个篇幅的知识， 创建小例子：smacking around hobbits!打孩子身边霍比特人！
为了打一个hobbit，我们首先模拟其身体部位。每个身体部位包括它的相对大小，以帮助我们确定它是如何可能的是这部分将受到打击。
为了避免重复，这霍比特模式将仅包括“左脚”项目，“左耳”等，因此，我们需要一个功能完全的对称化模型。
最后，我们将创建一个遍历我们的身体部位，并随机选择一击的功能。
为了打一个hobbit，我们首先模拟其身体部位。每个身体部位包括它的相对大小，以帮助我们确定它是如何可能的是这部分将受到打击。
为了避免重复，这霍比特模式将仅包括“左脚”项目，“左耳”等，因此，我们需要一个功能完全的对称化模型。
最后，我们将创建一个遍历我们的身体部位，并随机选择一击的功能。
1.1. The Shire's Next Top Model
对于我们的 hobbit 的模型，我们会避开这种特性为“joviality”和“mischievousness”和只注重hobbit的微小的身体。下面是我们的hobbit模型：
(def asym-hobbit-body-parts [{:name "head" :size 3}
{:name "left-eye" :size 1}
{:name "left-ear" :size 1}
{:name "mouth" :size 1}
{:name "nose" :size 1}
{:name "neck" :size 2}
{:name "left-shoulder" :size 3}
{:name "left-upper-arm" :size 3}
{:name "chest" :size 10}
{:name "back" :size 10}
{:name "left-forearm" :size 3}
{:name "abdomen" :size 6}
{:name "left-kidney" :size 1}
{:name "left-hand" :size 2}
{:name "left-knee" :size 2}
{:name "left-thigh" :size 4}
{:name "left-lower-leg" :size 3}
{:name "left-achilles" :size 1}
{:name "left-foot" :size 2}])
This is a vector of maps.每个映射具有主体部分的名称和主体部分的相对大小。例如：动画人物眼睛有1/3的他们的头的大小defn has-matching-part?
[part]
(re-find #"^left-" (:name part)))
(defn matching-part
[part]
{:name (clojure.string/replace (:name part) #"^left-" "right-")
:size (:size part)})
(defn symmetrize-body-parts
"Expects a seq of maps which have a :name and :size"
[asym-body-parts]
(loop [remaining-asym-parts asym-body-parts
final-body-parts []]
(if (empty? remaining-asym-parts)
final-body-parts
(let [[part & remaining] remaining-asym-parts
final-body-parts (conj final-body-parts part)]
(if (has-matching-part? part)
(recur remaining (conj final-body-parts (matching-part part)))
(recur remaining final-body-parts))))))
(symmetrize-body-parts asym-hobbit-body-parts)
; => the following is the return value
[{:name "head", :size 3}
{:name "left-eye", :size 1}
{:name "right-eye", :size 1}
{:name "left-ear", :size 1}
{:name "right-ear", :size 1}
{:name "mouth", :size 1}
{:name "nose", :size 1}
{:name "neck", :size 2}
{:name "left-shoulder", :size 3}
{:name "right-shoulder", :size 3}
{:name "left-upper-arm", :size 3}
{:name "right-upper-arm", :size 3}
{:name "chest", :size 10}
{:name "back", :size 10}
{:name "left-forearm", :size 3}
{:name "right-forearm", :size 3}
{:name "abdomen", :size 6}
{:name "left-kidney", :size 1}
{:name "right-kidney", :size 1}
{:name "left-hand", :size 2}
{:name "right-hand", :size 2}
{:name "left-knee", :size 2}
{:name "right-knee", :size 2}
{:name "left-thigh", :size 4}
{:name "right-thigh", :size 4}
{:name "left-lower-leg", :size 3}
{:name "right-lower-leg", :size 3}
{:name "left-achilles", :size 1}
{:name "right-achilles", :size 1}
{:name "left-foot", :size 2}
{:name "right-foot", :size 2}]
1.2. let
上面有这样的话：
(let [[part & remaining] remaining-asym-parts
final-body-parts (conj final-body-parts part)]
some-stuff)
将左边绑定右边一个简单的例子：
(let [x 3]
x)
; => 3
(def dalmatian-list
["Pongo" "Perdita" "Puppy 1" "Puppy 2"]) ; and 97 more...
(let [dalmatians (take 2 dalmatian-list)]
dalmatians)
; => ("Pongo" "Perdita")
let也使用于新范围
(def x 0)
(let [x 1] x)
; => 1
还可以参考现有绑定
(def x 0)
(let [x (inc x)] x)
; => 1
let的好处
1.通过let命名的东西清晰
2.它们允许计算一次表达式，再重复利用的结果。同样重要的是，当表达式具有副作用。
2.它们允许计算一次表达式，再重复利用的结果。同样重要的是，当表达式具有副作用。
;; Associate "part" with the first element of "remaining-asym-parts"
;; Associate "remaining" with the rest of the elements in "remaining-asym-parts"
;; Associate "final-body-parts" with the result of (conj final-body-parts part)
(let [[part & remaining] remaining-asym-parts
final-body-parts (conj final-body-parts part)]
(if (has-matching-part? part)
(recur remaining (conj final-body-parts (matching-part part)))
(recur remaining final-body-parts)))
注意 part, remaining, 和 final-body-parts 在let中每一个都可以利用多次. 如果不用 part, remaining, and final-body-parts 会很复杂，例如：
(if (has-matching-part? (first remaining-asym-parts))
(recur (rest remaining-asym-parts)
(conj (conj (conj final-body-parts part) (first remaining-asym-parts))
(matching-part (first remaining-asym-parts))))
(recur (rest remaining-asym-parts)
(conj (conj final-body-parts part) (first remaining-asym-parts))))
let是一个将name和value联系起来的方式
1.3. loop循环
(loop [iteration 0]
(println (str "Iteration " iteration))
(if (> iteration 3)
(println "Goodbye!")
(recur (inc iteration))))
; =>
Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Goodbye!
第一行 loop [iteration 0] 开始循环并介绍绑定初始值，就像用default value去调用匿名函数 . 第一次遍历, iteration 值为0
其次，它打印一个小消息。
然后，它会检查迭代的价值 ---如果它大于3，那么现在是时候说再见了。否则，我们再循环。
然后，它会检查迭代的价值 ---如果它大于3，那么现在是时候说再见了。否则，我们再循环。
这就像调用由loop产生的匿名函数，但这次我们把它传递一个参数，
下面例子可以完成同样的事情：
(inc iteration).。 下面例子可以完成同样的事情：
(defn recursive-printer
([]
(recursive-printer 0))
([iteration]
(println iteration)
(if (> iteration 3)
(println "Goodbye!")
(recursive-printer (inc iteration)))))
(recursive-printer)
; =>
Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Goodbye!
1.4. Regular Expressions正则表达式
正则表达式是用于对文本进行模式匹配工具。我不会进入他们的工作，但这里是他们的文字符号：
;; pound, open quote, close quote
#"regular-expression"
在第一个model处理中，有re-find 返回true or false 根据part's name是否starts with "left-":
(defn has-matching-part?
[part]
(re-find #"^left-" (:name part)))
(has-matching-part? {:name "left-eye"})
; => true
(has-matching-part? {:name "neckbeard"})
; => false
matching-part用正则表达式来用"right-"替换"left-"
(defn matching-part [part] {:name (clojure.string/replace (:name part) #"^left-" "right-") :size (:size part)}) (matching-part {:name "left-eye" :size 1}) ; => {:name "right-eye" :size 1}]
1.5. Symmetrizer
重点分析下 symmetrizer 。
(def asym-hobbit-body-parts [{:name "head" :size 3} {:name "left-eye" :size 1} {:name "left-ear" :size 1} {:name "mouth" :size 1} {:name "nose" :size 1} {:name "neck" :size 2} {:name "left-shoulder" :size 3} {:name "left-upper-arm" :size 3} {:name "chest" :size 10} {:name "back" :size 10} {:name "left-forearm" :size 3} {:name "abdomen" :size 6} {:name "left-kidney" :size 1} {:name "left-hand" :size 2} {:name "left-knee" :size 2} {:name "left-thigh" :size 4} {:name "left-lower-leg" :size 3} {:name "left-achilles" :size 1} {:name "left-foot" :size 2}]) (defn has-matching-part? [part] (re-find #"^left-" (:name part))) (defn matching-part [part] {:name (clojure.string/replace (:name part) #"^left-" "right-") :size (:size part)}) ; ~~~1~~~ (defn symmetrize-body-parts "Expects a seq of maps which have a :name and :size" [asym-body-parts] ; (loop [remaining-asym-parts asym-body-parts ; ~~~2~~~ final-body-parts []] (if (empty? remaining-asym-parts) ; ~~~3~~~ final-body-parts (let [[part & remaining] remaining-asym-parts ; ~~~4~~~ final-body-parts (conj final-body-parts part)] (if (has-matching-part? part) ; ~~~5~~~ (recur remaining (conj final-body-parts (matching-part part))) ; ~~~6~~~ (recur remaining final-body-parts))))))1.该功能采用了是常见于函数式编程的一般的策略。给定序列（a vector of body parts and their sizes ），连续的序列分割成一个“ head”和“ tail”。处理head，将它添加到了一些成绩，然后用递归来继续该过程的tail。
2. 循环开始在body parts。该序列的“tail”将被绑定到remaining-asym-parts。最初，它被绑定到完整序列传递给function，remaining-asym-parts。创建一个结果序列，final-body-parts;它的初始值是一个空vector。
3. 如果remaining-asym-parts 是空的，这意味着我们处理整个序列，并且可以返回结果 final-body-parts。
4. 否则，split the list into a head, part, and tail, remaining. 另外， 向 final-body-parts添加 part ，然后重新绑定结果final-body-parts.
5. 如果是这样，matching-part 加至final-body-parts and recur（循环），否则，只是recur。
1.6. Shorter Symmetrizer with Reduce
形式"process each element in a sequence and build a result"用 reduce函数。例如：
;; sum with reduce (reduce + [1 2 3 4]) ; => 10
就等于clojure中的
(+ (+ (+ 1 2) 3) 4)
因此, reduce works by doing this:
- 给定的函数应用于序列的前两个元素。这就是（+12）从何而来。
- 给定的函数应用到的结果与该序列的下一个元素。在例子中，步骤1的结果为3，并且该序列的下一个元素是3为好。所以，你最终得到（+3 3） 。
- 对序列中的每一个剩余的元素重复步骤2。 Reduce 也可选的初始值. 15是这里的初始值：
Reduce 也可选的初始值. 15是这里的初始值：
(reduce + 15 [1 2 3 4])如果提供的初始值，然后通过施加给定的函数的初始值和所述序列的第一个元素开始reduce，而不是该序列的前两个元素。
为了进一步了解reduce如何工作，这里有一个方法，它可以实现：
(defn my-reduce ([f initial coll] (loop [result initial remaining coll] (let [[current & rest] remaining] (if (empty? remaining) result (recur (f result current) rest))))) ([f [head & tail]] (my-reduce f (f head (first tail)) (rest tail))))我们可以重新实现 symmetrize，如下所示：
(defn better-symmetrize-body-parts "Expects a seq of maps which have a :name and :size" [asym-body-parts] (reduce (fn [final-body-parts part] (let [final-body-parts (conj final-body-parts part)] (if (has-matching-part? part) (conj final-body-parts (matching-part part)) final-body-parts))) [] asym-body-parts))
1.7. Hobbit Violence
现在，让我们创建一个函数，将决定 which part of the hobbit被击中：
(defn hit [asym-body-parts] (let [sym-parts (better-symmetrize-body-parts asym-body-parts) body-part-size-sum (reduce + 0 (map :size sym-parts)) target (inc (rand body-part-size-sum))] (loop [[part & rest] sym-parts accumulated-size (:size part)] (if (> accumulated-size target) part (recur rest (+ accumulated-size (:size part))))))) (hit asym-hobbit-body-parts) ; => {:name "right-upper-arm", :size 3} (hit asym-hobbit-body-parts) ; => {:name "chest", :size 10} (hit asym-hobbit-body-parts) ; => {:name "left-eye", :size 1}