Clojure常用模块

;; Arguably a bit cumbersome to read:
user=> (first (.split (.replace (.toUpperCase "a b c d")
                                "A"   "X")
                      " "))
"X"

;; Perhaps easier to read:
user=> (-> "a b c d" 
           .toUpperCase 
           (.replace "A" "X") 
           (.split " ") 
           first)
"X"

;; An example of using the "thread-last" macro to get
;; the sum of the first 10 even squares.
user=> (->> (range)
            (map #(* % %))
            (filter even?)
            (take 10)
            (reduce +))
1140

;; This expands to:
user=> (reduce +
               (take 10
                     (filter even?
                             (map #(* % %)
                                  (range)))))
1140

user=> (def my-fn (comp (partial * 10) - *))
user=> (my-fn 5 3) ;  10*(-(5*3))
-150

user=> (defn sum-even-numbers [nums]
         (if-let [nums (seq (filter even? nums))]
           (reduce + nums)
           "No even numbers found."))
user=> (sum-even-numbers [1 3 5 7 9])
"No even numbers found."
user=> (sum-even-numbers [1 3 5 7 9 10 12])
22

(defn drop-one
  [coll]
  (when-let [s (seq coll)]
    (rest s)))
user=> (drop-one [1 2 3])
(2 3)
user=> (drop-one [])
nil

(condp < n
       0    "n>0"
       10  "n>10"
       "n<=0")

(case x
    1 10
    2 20
    3 30
    0)

(case x
    (5 10) "*5"
    (3 6 9) "*3"
    "others")

(case x
    "JoC"   :a-book
    :eggs   :breakfast
    42      (+ x 100)
    [42]    :a-vector-of-42
    "The default")

user> (use 'clojure.contrib.def)
nil
user> (defnk f [:b 43] (inc b))
#'user/f
user> (f)
44
user> (f :b 100)
101
user=> (defnk with-positional [foo :b 43] (+ foo (inc b)))
#'user/with-positional
user=> (with-positional 5 :b 1)
7

'(a b :name 12.5) ;; list
['a 'b :name 12.5] ;; vector
{:name "Chas" :age 31} ;; map
#{1 2 3} ;; set 

(first '(:alpha :bravo :charlie)) ;;:alpha
(rest [1 2 3 4 5]) ;;(2 3 4 5),无论输入,都是返回seq
(rest [1]) ;;(),返回空seq, 而next会返回nil
(cons 1 '(2 3 4 5 6)) ;;(1 2 3 4 5 6), (cons x seq), 将单个x加入seq, 多用conj代替
(conj [:a :b :c] :d :e :f :g) ;;[:a :b :c :d :e :f :g],将后面多个elem逐个加入col
(seq {:a 5 :b 6}) ;;([:a 5] [:b 6]), 将各种coll转化为seq
(count [1 2 3]) ;;= 3
(reverse [1 2 3 4]) ;;(4 3 2 1)
(interleave [:a :b :c] [1 2]) ;;(:a 1 :b 2)

(range start? end step?)
(range 10) ;;(0 1 2 3 4 5 6 7 8 9)
(range 1 25 2)  ;;(1 3 5 7 9 11 13 15 17 19 21 23)

(group-by count ["a" "as" "asd" "aa" "asdf" "qwer"]) ;;{1 ["a"], 2 ["as" "aa"], 3 ["asd"], 4 ["asdf" "qwer"]}, group-by f coll

(sort > [42 1 7 11]), (42 11 7 1) ;;默认是升序, 这里改成降序

(nth [:a :b :c] 3) ;;= java.lang.IndexOutOfBoundsException, 等于([:a :b :c] 3)
(get [:a :b :c] 3) ;;nil,和nth的不同

(conj [] 1 2 3) ;[1 2 3]
(conj '() 1 2 3) ;(3 2 1)
(first (conj '() 1 2 3)) ;3
(first (conj [] 1 2 3)) ;1

(pop (conj [] 1 2 3)) ;[1 2], 和rest不同
(peek (conj [] 1 2 3)) ;3, 和first不同

; Adds a list to beginning of another.  Note that elements of list are added in reverse since each is processed sequentially.
(into '(1 2 3) '(4 5 6))
=> (6 5 4 1 2 3)

(into [5 6 7 8] '(1 2 3 4))
=> [5 6 7 8 1 2 3 4]        
(into #{5 6 7 8} [1 2 3 4])
=> #{1 2 3 4 5 6 7 8}  

user=> (merge {:a 1 :b 2 :c 3} {:b 9 :d 4})
{:d 4, :a 1, :b 9, :c 3} 

;; merge two maps using the addition function
user=> (merge-with + 
                   {:a 1  :b 2}
                   {:a 9  :b 98 :c 0})    
{:c 0, :a 10, :b 100}

(apply f e1 [e2 e3]) ;; (f e1 e2 e3)
(apply max [1 3 2]) ;; (max 1 3 2)

user=> (mapcat reverse [[3 2 1 0] [6 5 4] [9 8 7]])
(0 1 2 3 4 5 6 7 8 9)

user=> (for [x [0 1 2 3 4 5]
             :let [y (* x 3)]
             :when (even? y)]
            y)
(0 6 12)

user=> (for [x ['a 'b 'c] 
             y [1 2 3]] 
          [x y])

([a 1] [a 2] [a 3] [b 1] [b 2] [b 3] [c 1] [c 2] [c 3])

(doall (map println [1 2 3]))
1
2
3
(nil nil nil)

(dorun (map println [1 2 3]))
1
2
3
nil 

(doseq [x (range 7) y (range x) :while (odd? x)] (print [x y]))
(for [x (range 7) y (range x) :while (odd? x)] [x y])

user=> (doseq [x [1 2 3] 
               y [1 2 3]] 
         (prn (* x y)))
1
2
3
2
4
6
3
6
9
nil

(def v1 (ref 10))
(deref v1) ;;@v1
(dosync (ref-set v1 0)) ;;update
(dosync (ref-set v1 (inc @v1)))
(dosync (alter v1 inc)) ;;alter, read-and-set,后面跟函数
(dosync (alter v1 + 10))

(def v1 (atom 10))
(reset! v1 20) ; @v1=20 ;;单个值,所以不需要dosync来保证transaction
(swap! v1 + 3) ; @v1=23 ;;read-and-set

(def v2 (atom {:name "qh" :age 30}))
(swap! v2 assoc :age 25) ; @v2={:name "james" :age 25

(ns clojure.examples.hello
    (:gen-class))

(ns backtype.storm.scheduler.DefaultScheduler  
  (:gen-class
    :implements [backtype.storm.scheduler.IScheduler]))
(defn -prepare [this conf]
  )
(defn -schedule [this ^Topologies topologies ^Cluster cluster]
  (default-schedule topologies cluster))

user=> (def *files* (file-seq (java.io.File. "/tmp/")))
user=> (count (filter (memfn isDirectory) *files*))
68
user=> (count (filter #(.isDirectory %) *files*))
68

(defmacro memfn
  "Expands into code that creates a fn that expects to be passed an
  object and any args and calls the named instance method on the
  object passing the args. Use when you want to treat a Java method as
  a first-class fn."
  {:added "1.0"}
  [name & args]
  `(fn [target# ~@args]
     (. target# (~name ~@args))))

(defprotocol Foo
  (foo [this]))
(defprotocol Bar
  (bar [this]))
(extend java.lang.Number
  Bar
  {:bar (fn [this] 42)})

(satisfies? Foo 123)   ; => false
(satisfies? Bar 123)   ; => true

(with-test
  (defn hello [name]
    (str "Hello, " name))
  (is (= (hello "Brian") "Hello, Brian"))
  (is (= (hello nil) "Hello, nil")))

(hello "Judy") ;;"Hello, Judy"

((:test (meta #'hello)))
FAIL in clojure.lang.PersistentList$EmptyList@1 (NO_SOURCE_FILE:5)
expected: (= (hello nil) "Hello, nil")
  actual: (not (= "Hello, " "Hello, nil"))
false

(ns example.core
  (:use [clojure.tools.logging :only (info error)]))
(defn divide [x y]
  (try
    (info "dividing" x "by" y)
    (/ x y)
    (catch Exception ex (error ex "There was an error in calculation"))))

(log-message "test," (pr-str '(1 2 3 4 5)))

user=> (def x [1 2 3 4 5])
;; Turn that data into a string...
user=> (pr-str x)
"[1 2 3 4 5]"
;; ...and turn that string back into data!
user=> (read-string (pr-str x))
[1 2 3 4 5]