ClojureProgramming/ch12-patterns-repl-interactions.clj at master · Dwaynekj/ClojureProgramming

This repository was archived by the owner on Dec 12, 2021. It is now read-only.
392 lines (297 loc) · 7.18 KB
(defn- update-status*
  [service-name service-endpoint-url request-data-fn]
  (fn [new-status]
    (log (format "Updating status @ %s to %s" service-name new-status))
    (let [http-request-data (request-data-fn new-status)
          connection (-> service-endpoint-url java.net.URL. .openConnection)]
      ;; ...set request method, parameters, body on `connection`
      ;; ...perform actual request
      ;; ...return result based on HTTP response status
(def update-facebook-status (update-status* "Facebook" "http://facebook.com/apis/..."
                              (fn [status]
                                {:params {:_a "update_status"
                                 :method "GET"})))
(def update-twitter-status ...)
(def update-google-status ...)
interface IDog {
    public String bark();
class Chihuahua implements IDog {
    public String bark() {
        return "Yip!";
class Mastiff implements IDog {
    public String bark() {
        return "Woof!";
class PetStore {
    private IDog dog;
    public PetStore() {
        this.dog = new Mastiff();
    public IDog getDog() {
        return dog;
static class MyApp {
    public static void main(String[] args) {
        PetStore store = new PetStore();
        System.out.println(store.getDog().bark());
class PetStore {
    private IDog dog;
    public PetStore(IDog dog) {
        this.dog = dog;
    public IDog getDog() {
        return dog;
class MyApp {
    public static void main(String[] args) {
        PetStore store = new PetStore(new Chihuahua());
        System.out.println(store.getDog().bark());
(defprotocol Bark
  (bark [this]))
(defrecord Chihuahua []
  (bark [this] "Yip!"))
(defrecord Mastiff []
  (bark [this] "Woof!"))
(defrecord PetStore [dog])
  (let [store (PetStore. dog)]
    (println (bark (:dog store)))))
(main (Chihuahua.))
(main (Mastiff.))
(extend-protocol Bark
  java.util.Map
  (bark [this]
    (or (:bark this)
        (get this "bark"))))
(main (doto (java.util.HashMap.)
        (.put "bark" "Ouah!")))
(main {:bark "Wan-wan!"})
;= Wan wan!
{:dog #user.Chihuahua{:weight 12, :price "$84.50"}}
(defn configured-petstore
  (-> "petstore-config.clj"
    read-string
    map->PetStore))
(configured-petstore)
;= #user.PetStore{:dog #user.Chihuahua{:weight 12, :price "$84.50"}}
interface ISorter {
    public sort (int[] numbers);
class QuickSort implements ISorter {
    public sort (int[] numbers) { ... }
class MergeSort implements ISorter {
    public sort (int[] numbers) { ... }
class Sorter {
    private ISorter sorter;
    public Sorter (ISorter sorter) {
        this.sorter = sorter;
    public execute (int[] numbers) {
        sorter.sort(numbers);
class App {
    public ISorter chooseSorter () {
        if (...) {
            return new QuickSort();
        } else {
            return new MergeSort();
    public static void main(String[] args) {
        int[] numbers = {5,1,4,2,3};
        Sorter s = new Sorter(chooseSorter());
        s.execute(numbers);
        //... now use sorted numbers
(defn quicksort [numbers] ...)
(defn mergesort [numbers] ...)
(defn choose-sorter
    quicksort
    mergesort))
  (let [numbers [...]]
    ((choose-sorter) numbers)))
((comp reverse sort) [2 1 3])
abstract class Processor {
    protected Processor next;
    public addToChain(Processor p) {
        next = p;
    public runChain(data) {
        Boolean continue = this.process(data);
        if(continue and next != null) {
            next.runChain(data);
    abstract public boolean process(String data);
class FooProcessor extends Processor {
    public boolean process(String data) {
        System.out.println("FOO says pass...");
        return true;
class BarProcessor extends Processor {
    public boolean process(String data) {
        System.out.println("BAR " + data + " and let's stop here");
        return false;
class BazProcessor extends Processor {
    public boolean process(String data) {
        System.out.println("BAZ?");
        return true;
Processor chain = new FooProcessor().addToChain(new BarProcessor).addToChain(new BazProcessor);
chain.run("data123");
(defn foo [data]
  (println "FOO passes")
(defn bar [data]
  (println "BAR" data "and let's stop here")
(defn baz [data]
  (println "BAZ?")
(defn wrap [f1 f2]
  (fn [data]
    (when (f1 data)
      (f2 data))))
(def chain (reduce wrap [foo bar baz]))
(defn my-app
  [request]
  {:status 200
   :headers {"Content-type" "text/html"}
   :body (format "<html><body>You requested: %s</body></html>"
           (:uri request))})
(defn wrap-logger
  [handler]
  (fn [request]
    (println (:uri request))
    (handler request)))
(require '[ring.middleware cookies session])
(def my-app (-> my-app
                wrap-cookies
                wrap-session
                wrap-logger))
public class Foo
    public void expensiveComputation () {
        long start = System.currentTimeMillis();
        try {
            // do computation
        } catch (Exception e) {
            // log error
        } finally {
            long stop = System.currentTimeMillis();
            System.out.println("Run time: " + (stop - start) + "ms");
public class AspectJExample {
    public void longRunningMethod () {
        System.out.println("Starting long-running method"); 
        try {
            Thread.sleep((long)(1000 + Math.random() * 2000));
        } catch (InterruptedException e) {
public aspect Timing {
    pointcut profiledMethods(): call(* AspectJExample.* (..));
    long time;
    before(): profiledMethods() {
        time = System.currentTimeMillis();
    after(): profiledMethods() {
        System.out.println("Call to " + thisJoinPoint.getSignature() +
                " took " + (System.currentTimeMillis() - time) + "ms");
Starting long-running method
Call to void com.clojurebook.AspectJExample.longRunningMethod() took 1599ms
(defn time-it [f & args]
  (let [start (System/currentTimeMillis)]
      (apply f args)
      (finally
       (println "Run time: " (- (System/currentTimeMillis) start) "ms")))))
(require 'robert.hooke)
(defn foo [x y]                     
  (Thread/sleep (rand-int 1000))
(robert.hooke/add-hook #'foo time-it)
; Run time:  772 ms
(robert.hooke/with-hooks-disabled foo (foo 1 2))
(robert.hooke/remove-hook #'foo time-it)
;= #<user$foo user$foo@4f13f501>
(require 'clojure.set)
(doseq [var (->> (ns-publics 'clojure.set)
                 (map val))]
  (robert.hooke/add-hook var time-it))
(clojure.set/intersection (set (range 100000))
                          (set (range -100000 10)))
; Run time:  97 ms
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

ch12-patterns-repl-interactions.clj

Latest commit

History

ch12-patterns-repl-interactions.clj

File metadata and controls
