Clojure学习笔记

• (defn<符号><值?>)：把符号绑到值上（如果有的话）。如果有必要创建与符号对应的var。
• (fn<名称>?[<参数>*]<表达式>*)：返回带有特定参数的函数值，并把它们应用到表达式上。通常跟(def)相结合，变成形式(defn)
• (if<test><then><else>?)：如果test的计算结果为true，计算then并产出其结果。否则计算else并产出其结果，当然，前提是else存在。
• (let[<绑定>*]<表达式>*)：给局部名称分配别名值，并隐式定义一个作用域。使得在let作用域内的所有表达式都能获得该别名。
• (do<表达式>*)：按顺序计算表达式的值，并产出最后一个结果
• (quote<形式>)：照原样返回形式（不经计算）。它只能接受一个形式参数，其他的参数全都会被忽略。
• (var<符号>)：返回与符号对应的var（返回一个Clojure JVM对象，不是值）

• Clojure的关键字是只有一个参数的函数，其参数必须是映射。
• 在映射上调用这个函数会返回映射里与该关键字函数对应的值。
• 关键字的使用遵循语法对称性规则，即(my-map:key)和(:key my-map)都是合法的。
• 关键字作为值使用时返回自身
• 关键字在使用之前无需声明或def。
• Clojure中的函数也是值，因此可以放在映射里当键用。
• 可以用逗号（但没必要）来分隔键值对，因为Clojure会把他们当做空格处理
• 除了关键字，其他符号也能用在映射里做键，但关键字太好用了们所以我们要特别提出来，你应该把它用在自己的代码中。

• 更强健的迭代器，特别是对于多路算法而言。
• 不可变能力，可以安全地在函数间传递序列。
• 实现了懒序列的可能性。

import clojure.lang.ISeq;
import clojure.lang.StringSeq;
/**
 * Created with IntelliJ IDEA.
 * User: billlee
 * Date: 2015/1/13
 * Time: 16:04
 * To change this template use File | Settings | File Templates.
 */
public class ClojureDemo {
    public static void main(String[] args) {
        ISeq seq= StringSeq.create("football");
        while(seq!=null)
        {
            Object first=seq.first();
            System.out.println("Seq:"+seq+"  ;first:"+first);
            seq=seq.next();
        }
    }
}

(ns com.clojure.ClojureDemo)
(def hello (fn [] "Hello world"))
(hello)
;使用java中的toString()结合length()获取字符串长度
(defn lenStr [y] (.length (.toString y)))
(defn schwartz [x f]
      (map #(nth %1 0)
           (sort-by #(nth %1 1)
                    (map #(let [w %1] (list w (f w)))x))))
(schwartz ["sads" "21" "ssssewe" "22323" "223" "s"] lenStr)
'(1 2 3 4 5)
(quote (1 23 45 32 545))
(vector 1 2 3)
(vec '(1 2 3 4 5))
[1 2 3 4 5 4 5 2]
["ssa" 2 "dsadsa" "321" 221]
(nth '(1 2 3 "433" "rewr" "e33") 4)
(def foo {"aaa" "111" "bbb" 22222})
(foo "aaa")
(foo "bbb")
(def martijn {:name "Martijn Verburg",:city "London",:area "Highbury"})
(:name martijn)
(:city martijn)
(def ben {:name "ben Evans",:city "London",:area "Holloway"})
(def authors [ben martijn])
(map ( fn [y] (:name y)))
(map ( fn [y] (:name y)) authors)
(+ 3 4)
(defn add [x y] (+ x y))
(+ 2 3 4 56)
(def list-int '(1 2 3 4))
(def vect-int (vec list-int))
(identical? list-int vect-int)
(defn const-fun1 [y] 1)
(defn iden-fun [y] y)
(defn list-maker-fun [x f]
      (map (fn [z] (let [w z]
                        (list w (f w))))x))
(list-maker-fun ["a"] const-fun1)
(list-maker-fun ["a" "b"] const-fun1)
(list-maker-fun [3 4 65] iden-fun)
(schwartz [33 452 53 42 555] iden-fun)
(defn like-for [counter]
      (loop [ctr counter]
            (println ctr)
            (if (< ctr 10)
              (recur (inc ctr))
              ctr)))
(like-for 100)
(like-for 60)
(like-for 6)
(like-for 1)
(defn like-for [counter]
      (loop [ctr counter]
            (println ctr)
            (if (< ctr 100)
              (recur (inc ctr))
              ctr)))
(like-for 99)
(like-for 1)
(defn adder [constToAdd] #(+ constToAdd %1))
(def plus2 (adder 2))
(plus2 222)
(def plus100 (adder 100))
(plus100 22)
(rest '(1 2 3))
(first '(1 2 43 54))
(rest [1 23 45])
(seq ())
(seq [])
(seq '(1 2 3 4))
(seq [22 1 "re" "fdsw" "fdsf" "fdsffd"])
(cons 1 [2 34 43])
(defn next-big-n [n] (let [new-val (+ 1 n)]
                          (lazy-seq (
                                      cons new-val (next-big-n new-val)
                                           ))))
(defn natural-k [k]
      (concat [k] (next-big-n k)))
(take 10 (natural-k 3))
(defn const-fun-arity1
      ([] 1)
      ([x] 1)
      ([x & more] 1))
(const-fun-arity1 1)
(const-fun-arity1 1 2)
(const-fun-arity1 1 2 3)
(defn const-fun-arity1
      ([] 0)
      ([x] 1)
      ([x & more] "more"))
(const-fun-arity1)
(const-fun-arity1 1 )
(const-fun-arity1 1 2 3)
(System/getProperty "java.vm.version")
(import '(java.util.concurrent CountDownLatch LinkedBlockingQueue))
(def cdl (new CountDownLatch 2))
(def lbq (LinkedBlockingQueue.))
(.getClass "test")
(.getClass 2.3)
(.getClass [12 34 534])
(.getClass '(1 2 3 4))
(.getClass (fn [] "Hello world"))
(import '(java.util.concurrent Executors LinkedBlockingQueue TimeUnit))
(def stpe (Executors/newScheduledThreadPool 2))
(def lbq (LinkedBlockingQueue.))
(def msgRdr (proxy [Runnable] []
                   (run [] (.toString (.poll lbq)))))
(def rdrHndl (.scheduleAtFixedRate stpe msgRdr 10 10 TimeUnit/MILLISECONDS))
(import '(java.util ArrayList LinkedList))
(.getClass (.iterator (ArrayList.)))
(.getClass (.iterator (LinkedList.)))
(def simple-future (future (do (println "hello world Line0")
                               (Thread/sleep 10000)
                               (println "we are the world Line1")
                               (Thread/sleep 10000)
                               (println "do the best Line 2"))))
(defn wait-with-for [limit]
      (let [counter 1]
           (loop [ctr counter]
                 (Thread/sleep 500)
                 (println (str "Ctr=" ctr))
                 (if (< ctr limit)
                   (recur (inc ctr))
                   ctr))))
(defn wait-1 [] (wait-with-for 1))
(defn wait-2 [] (wait-with-for 2))
(defn wait-3 [] (wait-with-for 3))
(def wait-seq (pcalls wait-1 wait-2 wait-3))
(first wait-seq)
(first (next wait-seq))
(defn make-new-acc [account-name opening-balance]
      {:name account-name :bal opening-balance})
(defn loop-and-debit [account]
      (loop [acc account]
            (let [balance (:bal acc) my-name (:name acc)]
                 (Thread/sleep 1)
                 (if (> balance 0)
                   (recur (make-new-acc my-name (dec balance)))
                   acc))))
(loop-and-debit (make-new-acc "Ben" 600))
(defn make-new-acc [account-name opening-balance]
      (ref {:name account-name :bal opening-balance}))
(defn alter-acc [acc new-name new-balance]
      (assoc acc :bal new-balance :name new-name))

(defn loop-and-debit [account]
      (loop [acc account]
            (let [balance (:bal @acc)
                  my-name (:name @acc)]
                 (Thread/sleep 1)
                 (if (> balance 0)
                   (recur (dosync (alter acc alter-acc my-name (dec balance)) acc))
                   acc)
                 )))
(def my-acc (make-new-acc "Ben" 500))
(defn my-loop [] (let [the-acc my-acc]
                      (loop-and-debit the-acc)))
(pcalls my-loop my-loop my-loop my-loop my-loop)
(defn wait-and-log [coll str-to-add]
      (do (Thread/sleep 10000)
          (let [my-coll (conj coll str-to-add)]
               (Thread/sleep 10000)
               (conj my-coll str-to-add))))
(def str-coll (agent []))
(send str-coll wait-and-log "some str")
@str-coll