(defun eshell-execute-selection () "Insert text of current selection or clipboard in eshell and execute." (interactive) (require 'eshell) (let ((command (or (buffer-substring (mark) (point)) x-last-selected-text-clipboard))) (let ((buf (current-buffer))) (unless (get-buffer eshell-buffer-name) (eshell)) (display-buffer eshell-buffer-name t) (switch-to-buffer-other-window eshell-buffer-name) (end-of-buffer) (eshell-kill-input) (insert command) (eshell-send-input) (end-of-buffer) (switch-to-buffer-other-window buf))))
(ns compact "compact a string by removing extra white spaces") (defn compact [s] (reduce #(str %1 " " %2) (filter #(seq %) (seq (.split s " ")))))
(compact " Your uncompact String ")-> "Your uncompact String"
' Your uncompact String ' withBlanksCondensed
-> 'Your uncompact String'import (java.net NetworkInterface)) (def ip (let [ifc (NetworkInterface/getNetworkInterfaces) ifsq (enumeration-seq ifc) ifmp (map #(bean %) ifsq) ipsq (filter #(false? (% :loopback)) ifmp) ipa (map :interfaceAddresses ipsq) ipaf (nth ipa 0) ipafs (.split (str ipaf) " " ) ips (first (nnext ipafs))] (str (second (.split ips "/")))))
1: (defn N [p dc]
2: (/ (Math/log (- 1 dc))
3: (Math/log (- 1 p))))
4:
5: (defn DC [p n]
6: (let [np (- 1 p)
7: pp (Math/pow np n)]
8: (- 1 pp)))
9:
10: (defn k-factorial [n]
11: (reduce * (range 1 (inc n))))
12:
13: (defn permutation [n k]
14: (/ (k-factorial n)
15: (k-factorial (- n k))))
16:
17: (defn combination [n k]
18: (/ (k-factorial n)
19: (* (k-factorial k)
20: (k-factorial (- n k)))))
21:
22: (defn- k-filter [el coll]
23: (filter #(not (= el %)) coll))
24:
25: (defn permutations [n coll]
26: (if (= n 1)
27: (map #(vector %) coll)
28: (for [el coll nlis (permutations (- n 1) (k-filter el coll))]
29: (conj nlis el))))
30:
31: (defn combinations [n coll]
32: (set (map set (permutations n coll)))) Clojure has a special form called "let" and "binding", which are actually implemented as macros. It can get confusing sometimes. If you have read "Programming Clojure" book, you might be thinking that it is easy to use them correctly considering following straightforward example:Basically, "let" creates a lexical scoped Vars, which is local to the code block or a procedure where it is initially defined. Therefore, in the example above, "let" just created a new "x" with the value of "new value". But it is not local to the function "print-x". That is to say, "print-x" have no knowledge of the local scoped binding that is created by "let". "binding" macro instead creates a new binding for the already existed var, "x" with the "new value". Since "print-x" is evaluated within the "binding" form, the newly bound value is visible to any chained calls within the form. All nice and easy. However, it is not that obvious to understand and use them correctly. Look at following example:"let" example is just fine. It created a new var "y" with the value of 5 bound to it. But what is going on with the "binding" example? If we dig little deeper to Clojure API doc, we learn that the new bindings in "binding" are made in parallel, not sequential as it is in "let". Therefore, existing var "y" gets bound to the root binding of "x" not the overshadowed value of "x", which is the case in the "let example".OK, so far so good. Let us look at another example:Line 20-29 is pretty straight forward. But how about line 30? Shouldn't it call "print-y" function? Not really. It is because the anonymous function is evaluated outside of the "binding" form.
Just enclose the anonymous function within parenthesis. What do we learn from all of the above? Here are the summary that helps one use "let" and "binding" correctly:
- Use "binding" only if you are trying to alter a behavior dynamically for special-vars that is already defined. Enclose your special vars within * as recommended by idiomatic clojure to make your intent clear.
- Use "let" for locally scoped vars and avoid shadowing already defined vars.
- Remember "let" binding is sequential and "binding" binding is done in parallel.
- Pay close attention to the scope of the "binding" form. Any expression that is not evaluated inside the form, will not see the binding. That is to say, binding in "binding" form is thread local starting from the "binding" form until it ends including any expression that is chained within the form, which is what the thread-local are all about.
I posted this so that it helps someone trying to find his or her way in the wonderful world of Clojure.
1: (def arabic-roman-map
2: {1 "I", 5 "V",
3: 10 "X", 50 "L",
4: 100 "C", 500 "D",
5: 1000 "M",
6: 4 "IV", 9 "IX",
7: 40 "XL", 90 "XC",
8: 400 "CD", 900 "CM" })
9: (def arabic-roman-map-sorted-keys
10: (sort (keys arabic-roman-map)))
11: (defn find-value-in-coll
12: [coll k]
13: (let [aval (find coll k)]
14: (if (nil? aval) "" (val aval))))
15: (defn to-roman
16: [result n]
17: (let
18: [closest-key-for-n (last (filter #(> n %) arabic-roman-map-sorted-keys))
19: roman-value-for-n (find-value-in-coll arabic-roman-map n)
20: roman-value-for-closet-to-n (find-value-in-coll arabic-roman-map
21: closest-key-for-n)]
22: (if (or (<= n 0) (contains? arabic-roman-map n))
23: (conj result roman-value-for-n)
24: (recur (conj result roman-value-for-closet-to-n)
25: (- n closest-key-for-n)))))
26: Usage: >(to-roman [] 1999)
27: result: ["M" "CM" "XC" "IX"]
1: def decode(list:List[(Int,Any)]):List[Any] = {
2: val b = new ListBuffer[Any]()
3: var temp = list
4: while(!temp.isEmpty){
5: for(i<- 1 to temp.head._1){
6: b+=temp.head._2 }
7: temp = temp.tail
8: }
9: b.toList
10: }
11: println("input List = "+dlist)
12: println(decode(dlist))