Exploring Clojure with Factorials

Presentation to Clojure NYC meetup , Sept 2012

Transcript

1. Exploring Clojure with Factorials Noah Zucker @noahlz / nzucker@gmail.com
2. Factorials in Java
3. public static int calculate(int n) { if(n == 1) return 1; int result = 1; for (int i = n; i > 1; i--) { result *= i; } return result; }
4. public static int calculateRecursively(int n) { if(n == 0) return 1; return (n * calculateRecursively(n - 1)); }
5. Clojure: First Steps
6. (defn factorial-using-recur [n] (loop [current n next (dec current) total 1] (if (> current 1) (recur next (dec next) (* total current)) total)))
7. user=> (* 1 2 3 4 5) 120
8. (defn factorial-using-apply-range [n] (apply * (range 1 (inc n))))
9. (defn factorial-using-apply-iterate [n] (apply * (take n (iterate inc 1))))
10. (defn factorial-using-reduce [n] (reduce * (range 1 (inc n))))
11. Higher Order Functions ♦ “Data is Code”
12. (defn make-fac-function [n] (fn [] (reduce * (range 1 (inc n)))))
13. user=> (def fac5 (make-fac-function 5)) #'user/fac5 user=> (fac5) 120
14. (defn factorial-using-eval-and-cons [n] (eval (cons '* (range 1 (inc n)))))
15. user=> (def fac-expr (cons '* (range 1 6))) #'user/fac-expr user=> fac-expr (* 1 2 3 4 5) user=> (eval fac-expr) 120
16. (defmacro factorial-function-macro [n] `(fn [] (* ~@(range 1 (inc n)))))
17. user=> (macroexpand '(factorial-function-macro 5)) (fn* ([] (clojure.core/* 1 2 3 4 5))
18. Effective Java
19. public interface ValueComputer<T> { T compute(); }
20. public class Factorial implements ValueComputer<Integer> { private final int; private Factorial(int n) { this.n = n; } public Integer compute() { return calculate(n); } }
21. public static class Builder { private int n; public Builder factorial(int n) { this.n = n; return this; } public Factorial build() { return new Factorial(n); } }
22. Factorial.Builder builder = new Factorial.Builder(); builder.factorial(5); ValueComputer computer = builder.build(); System.out.println("5! = " + computer.compute());
23. Java Interop
24. (defn factorial-using-javainterop [n] (example.Factorial/calculate n))
25. (import 'example.Factorial$Builder) (defn factorial-using-javainterop-and-pipeline [n] (-> (Factorial$Builder.) (.factorial n) .build .compute))
26. user=> (clojure.walk/macroexpand-all '(-> (Factorial$Builder.) (.factorial 5) .build .compute)) (. (. (. (new Factorial$Builder) factorial 5) build) compute) Equivalent: (.compute (.build (.factorial (new Factorial$Builder) 5))))
27. (defn newFactorialComputer [n] (reify example.ValueComputer (compute [this] (factorial-using-reduce n))))
28. (require '[incanter.core :only factorial]) (defn factorial-from-incanter [n] (incanter.core/factorial n)) (http://incanter.org)
29. Clojure Concurrency in Practice
30. (defn factorial-using-ref-dosync [n psz] (let [result (ref 1) parts (partition-all psz (range 1 (inc n))) tasks (for [p parts] (future (Thread/sleep (rand-int 10)) (dosync (alter result #(apply * % p)))))] (dorun (map deref tasks)) @result))
31. (defn factorial-using-agent [n psz] (let [result (agent 1) parts (partition-all psz (range 1 (inc n)))] (doseq [p parts] (send result #(apply * % p))) (await result) @result))
32. (defn factorial-using-pmap-reduce [n psz] (let [parts (partition-all psz (range 1 (inc n))) sub-factorial-fn #(apply * %)] (reduce * (pmap sub-factorial-fn parts))))
33. Rube-Goldberg Factorials
34. (declare facseq) (defn factorial-using-lazy-seq [n] (nth (facseq) n)) (defn- facseq ([] (facseq 1 1)) ([n v] (let [next-n (inc n) next-v (* n v)] (cons v (lazy-seq (facseq next-n next-v))))))
35. (defrecord Factorial [n value]) (defmulti factorial-using-multimethods (fn ([limit] true) ([limit {:keys [n]}] (< n limit))))
36. (defmethod factorial-using-multimethods true ([limit] (factorial-using-multimethods limit (new Factorial 1 1))) ([limit fac] (let [next-factorial (-> fac (update-in [:n] inc) (update-in [:value] #(* % (:n fac))))] (factorial-using-multimethods limit next-factorial)))
37. (defmethod factorial-using-multimethods false ([limit fac] (* limit (:value fac))))
38. (defn factorial-for-trampoline [n] (letfn [(next-fac-value [limit current-step previous-value] (let [next-value (* current-step previous-value)] (if (= limit current-step) next-value #(next-fac-n limit current-step next-value)))) (next-fac-n [limit previous-step current-value] #(next-fac-value limit (inc previous-step) current-value))] (next-fac-value n 1 1)))
39. user=> (trampoline (factorial-for-trampoline 5)) 120
40. (defn factorial-using-areduce [n] (let [arr (long-array n)] (dotimes [i n] (aset-long arr i (inc i))) (areduce arr idx ret (long 1) (* ret (aget arr idx)))))
41. http://github.com/noahlz/factorials
42. EPILOGUE
43. Don't Do This! (defn factorial-using-do-while [n] (do (def a 0) (def res 1) (while (< a n) (def a (inc a)) (def res (* res a))) res))