vorlesung_5.12.clj

(ns repl.core
  (:refer-clojure :exclude [replace])
  (:require [clojure.test :as t])
  (:use [clojure.string :only (replace join)]
        [clojure.repl :rename {dir ls}]
        repl.greeter.friendly-hello)
  (:import (java.util Date Timer Random)
           java.io.File
           (javax.swing JFrame JPanel) ))


(defn- internal [] -1)

(comment 

  ;; Wiederholung
  ;; ------------------------------------------------------------------------------------
  
  (def log-file (agent []))
  
  (defn debug [& words]
    (send log-file
          (fn [x]
            (Thread/sleep 1000)
            (conj x (apply str (interpose " " words))))))

  (doc debug)

  (defn debug
    "Append some words to the log file"
    [& words]
    (send log-file
          (fn [x]
            (Thread/sleep 1000)
            (conj x (apply str (interpose " " words))))))

  (doc debug)
  
  (time
   (do
     (debug "Eine" "Ausgabe," "die" "an" "einem" "Stück" "erfolgen" "soll")
     (debug "Noch" "eine" "Ausgabe")))
  
  (do  (await log-file) @log-file)


  ;; future & promise

  (def x (future (do (Thread/sleep 5000))))
  @x
  (read-string "@x")

  (deref x 100 :timeout)

  
  (def x (promise))
  (deliver x 10) 
  @x
  
  ;; destructuring

  (let [[_ a & r :as l] [1 2 3]] (println a r l))

  (let [point {:x -210 :y 7100}
        {:keys [x y z] :or {x 0 y 0 z 0} :as p} point] (println x y z p))
  

  ;; Namespaces

  (import java.io.File)
  
  ;; require = load  
  ;; Datei $CLASSPATH/repl/greeter/friendly_hello.clj
  (require 'repl.greeter.friendly-hello) 
  (repl.greeter.friendly-hello/msg! "John" "Michael")

  ;; Alias
  (require '[repl.greeter.friendly-hello :as hello])
  (hello/msg! "John" "Jens")

  zipper ;; error
  clojure.zip/zipper
  
  (require 'clojure.zip) 
  zipper
  clojure.zip/zipper
  
  (refer 'clojure.zip :except '[next])
  zipper

  ;; use = require + refer

  ;; ------------------------------------------------------------------------------------
  ;; ------------------------------------------------------------------------------------
  
  
  
  ;; Namespace Macro (s. oben)
  
  ;; ------------------------------------------------------------------------------------
  ;; Vars definieren

  (def v 4)
  (defn foo [x] x)
  
  (def *foo* 17)
  (def ^:dynamic *foo* 17)
  
  ;; ------------------------------------------------------------------------------------
  ;; Vars & Concurrency 

  *clojure-version*

  (defn printv [ctx]
    (println ctx *clojure-version*))

  (printv "root")

  (binding [*clojure-version* :bar]
    (println *clojure-version*))

  (let [*clojure-version* :foo]
    (println *clojure-version*))

  (let [*clojure-version* :bar]
    (printv "let"))

  (binding [*clojure-version* :bar]
    (printv "binding"))

  (binding [foo 10])
  (binding [*foo* 10])

  ;; emacs bug -> nrepl-server-repl öffnen

  (defn new-thread [f] (.start (Thread. f)))
  
  (new-thread
   #(printv "t1"))
  
  (binding [*clojure-version* :bar]
    (new-thread #(printv "t2")))

  (do
    (binding [*clojure-version* 42]
      (new-thread #(printv "t3"))
      (printv "t4"))
    (printv "t5"))
  

   
  ;; Evaluation von Symbolen
  ;; ------------------------------------------------------------------------------------

  1
  :a
  [:a 1]
  {:a 1}
  (+ 1 2)
  ding

  (defn foo [] 42)
  foo
  (foo)
  (var foo)
  #'foo
  (#'foo)
  @#'foo
  (@#'foo)

  (def bar1 foo)
  bar1
  (bar1)
  #'bar1
  #'foo

  (def bar2 #'foo)
  bar2

  (def bar3 #'bar2)
  bar3
  @bar3
  @@bar3
  (eval bar3)
  (bar3)

  ;; Evaluationsreihenfolge
  ;; ------------------------------------------------------------------------------------

  ;; 1) qualified symbols  
  (def java.io.Writer 101)
  repl.core/java.io.Writer
  java.io.Writer

  ;; 2) Java-Class
  (let [java.io.Writer 12] java.io.Writer) ;; error

  
  ;; 3) locals
  (def foo 10)
  (let [foo 11] foo)
  (let [foo 11] repl.core/foo)
  

  ;; 4) Symbols
  foo
  ;; 5) Error
  sdfjks

  ;; Namespaces 
  ;; ------------------------------------------------------------------------------------

  (def m (ns-map 'repl.greeter.friendly-hello))
  (keys m)
 
  (first m)
  (map type (first m))

  (def f (get m (symbol "msg!")))
  (f "jens" "michael")

  (apropos "ns-")

  (def n 'repl.core)

  (ns-publics n)
  (keys (ns-publics n))
  (keys (ns-interns n))

  (clojure.set/difference
   (set (keys (ns-interns n)))
   (set (keys (ns-publics n))))

  (map type (first (ns-interns n)))
 
  (keys (ns-imports n))
  (map type (first (ns-imports n)))

  (ns-aliases n)
  (first  (ns-refers n))

  t/do-report
  (ns-unalias n 't)
  
  t/do-report 

  (msg! "you")
  (def msg! 17) ;; error
  (ns-unmap n 'msg!)
  (def msg! (constantly 17))
  (msg! "you")

  (def msg! repl.greeter.friendly-hello/msg!)
  (msg! "you")
  (def msg! (constantly 17))

  ;; Clojure - Java Interop
  ;; ------------------------------------------------------------------------------------

  (File. ".") ;; new File(".")
  (macroexpand-1  '(File. "."))

  (doc new)

  Math/PI ;; Math.PI

  (def r (Random.))

  (.nextInt r) ;; r.nextInt()
  (.nextInt r 100) ;; r.nextInt(100) 

  (.. r nextInt toString hashCode) ;; r.nextInt().toString().hashCode()

  #_(defn t [f] (.start (Thread. f))) ;; new Thread(f).start()
  
  ;; vgl. ->, ->>
  
  (-> [1 2 3 4] (conj ,,, 5) reverse)
  (reverse (conj [1 2 3 4] 5))
  
  (->> [1 2 3 4] (map inc ,,,) (filter even? ,,,) (reduce + ,,,))
  (reduce + (filter even? (map inc [1 2 3 4])))

  ;; ---
  
  (doto
    (JFrame. "Tralala")
    (.setSize 800 600)
    (.setVisible true))
  
  ;; j = new JFrame("Tralala");
  ;; j.setSize(800,600);
  ;; j.setVisible(true);

  ;; Warum mögen Clojure Programmierer doto nicht besonders?

  ;; ------------------------------------------------------------------------------------

  ;; Java -> Clojure

  ;; idiomatischer Java code (apache.commons):

  ;;  public static boolean isBlank(final CharSequence cs) {
	;;          int strLen;
	;;          if (cs == null || (strLen = cs.length()) == 0) {
	;;              return true;
	;;          }
	;;          for (int i = 0; i < strLen; i++) {
	;;              if (Character.isWhitespace(cs.charAt(i)) == false) {
	;;                  return false;
	;;              }
	;;          }
	;;          return true;
	;;      }
  
  
  ;; Schritt 1: Weg mit den Types 

  ;;  public isBlank(cs) {
  ;;          if (cs == null || (strLen = cs.length()) == 0) {
  ;;              return true;
  ;;          }
  ;;          for (int i = 0; i < strLen; i++) {
  ;;              if (Character.isWhitespace(cs.charAt(i)) == false) {
  ;;                  return false;
  ;;              }
  ;;          }
  ;;          return true;
  ;;      }
  
  ;; Schritt 2: HOF 

  ;;  public isBlank(cs) {
  ;;          if (cs == null || (strLen = cs.length()) == 0) {
  ;;              return true;
  ;;          }
  ;;          return every (c in cs) {
  ;;              Character.isWhitespace(c)
  ;;          }
  ;;      }


  ;; Schritt 3: Corner Cases eliminieren 

  ;;  public isBlank(cs) {
  ;;         return  every (c in cs) {
  ;;              Character.isWhitespace(c)
  ;;          }
  ;;      }


  ;; Schritt 4: Clojure Syntax

  (defn blank? [cs]
    (every? #(Character/isWhitespace %) cs))

  (blank? "      x      ")
  (blank? "               ")

  ;; ------------------------------------------------------------------------------------

  ;; Records
  (defrecord Foo [x y z])

  (def foo (Foo. :a :b :c))

  (:y foo)

  (type foo)

  (supers (type foo))

  (def bar (assoc foo :n 1))

  bar
  (type bar)

  (defn kehrwert [x]
    (try (/ 1 x)
         (catch Exception e :inf)
         (finally (println "done."))))

  (kehrwert 2)
  (kehrwert 0)

  (defn rodäng!!! [] (throw (RuntimeException. "RodängDBException")))

  (def e (RuntimeException. "RodängDBException"))

  (map #(instance? % e) [String Throwable Exception RuntimeException])