.nrepl-history

(use 'midi)
(def launchpad (midi-in))
(defn midi-inst-player [inst]
  (let [notes* (atom {})]
    (fn [event ts]
      (clojure.pprint/pprint event)
      (clojure.pprint/pprint ts)
      )))
(midi-handle-events launchpad adam-handler)
(use 'midi)
(def launchpad (midi-in))
(defn midi-inst-player [inst]
  (let [notes* (atom {})]
    (fn [event ts]
      (clojure.pprint/pprint event)
      (clojure.pprint/pprint ts)
      )))
(midi-handle-events launchpad adam-handler)
(defn adam-handler
  (let [notes* (atom {})]
    (fn [event ts]
      (clojure.pprint/pprint event)
      (clojure.pprint/pprint ts)
      )))
(defn adam-handler []
  (let [notes* (atom {})]
    (fn [event ts]
      (clojure.pprint/pprint event)
      (clojure.pprint/pprint ts)
      )))
(midi-handle-events launchpad adam-handler)
(defn print-handler []
  (let [notes* (atom {})]
    (fn [event ts]
      (with-open [w (clojure.java.io/writer "test.txt")]
    
      (.write w (with-out-str 
        (clojure.pprint/pprint event)))
      
      ))))
(midi-handle-events launchpad print-handler)
(use 'midi)
(def launchpad (midi-in))
(def notes* (atom {}))
(defn print-handler [notelog]
  (fn [event ts]
   (cond
      (= (:cmd event) :note-on)
        (swap! notelog assoc (:note event) (inst :note (:note event) :velocity (:vel event)))
 
      (or (= (:cmd event) :note-off)
          (and (not (zero? (:note event)))
               (zero? (:vel event))))
        (if-let [note-id (get @notes* (:note event))]
         (ctl note-id :gate 0)))))
(defn print-handler [notelog]
  (fn [event ts]
   (cond
      (= (:cmd event) :note-on)
        (swap! notelog assoc (:note event) "yay!")
 
      (or (= (:cmd event) :note-off)
          (and (not (zero? (:note event)))
               (zero? (:vel event))))
        (if-let [note-id (get @notes* (:note event))]
         (ctl note-id :gate 0)))))
(defn print-handler [notelog]
  (fn [event ts]
   (cond
      (= (:cmd event) :note-on)
        (swap! notelog assoc (:note event) "yay!")
 
      (or (= (:cmd event) :note-off)
          (and (not (zero? (:note event)))
               (zero? (:vel event))))
        (if-let [note-id (get @notelog* (:note event))]
         (swap! notelog dissoc (:note event)) ))))
(defn print-handler [notelog]
  (fn [event ts]
   (cond
      (= (:cmd event) :note-on)
        (swap! notelog assoc (:note event) "yay!")
 
      (or (= (:cmd event) :note-off)
          (and (not (zero? (:note event)))
               (zero? (:vel event))))
        (if-let [note-id (get @notelog (:note event))]
         (swap! notelog dissoc (:note event)) ))))
(midi-handle-events launchpad (print-handler notes*))
notes
notes*
(use 'midi)
(def notes* (atom {}))
(defn print-handler [notelog]
  (fn [event ts]
   (cond
      (= (:cmd event) :note-on)
        (swap! notelog assoc (:note event) "yay!")
 
    )))
(midi-handle-events launchpad (print-handler notes*))
(def launchpad (midi-in))
(midi-handle-events launchpad (print-handler notes*))
note*
notes*
(defn print-handler [notelog]
  (fn [event ts]
    (swap! notelog assoc :last-e event :last-ts ts)
 
    )))
(defn print-handler [notelog]
  (fn [event ts]
    (swap! notelog assoc :last-e event :last-ts ts)
 
    ))
(midi-handle-events launchpad (print-handler notes*))
notes*
(get @notelog :last-e)
(get @notes :last-e)
(get @notes* :last-e)
(get @notes* :last-ts)
(use 'midi)
(def launchpad (midi-in))
(def notes (atom {}))
(defn print-handler [notelog]
  (fn [event ts]
    (swap! notelog assoc :last-e event :last-ts ts)
 
    ))
      ; (or (= (:cmd event) :note-off)
      ;     (and (not (zero? (:note event)))
      ;          (zero? (:vel event))))
      ;   (if-let [note-id (get @notelog (:note event))]
      ;    (swap! notelog dissoc (:note event))) 
        ; )))
(midi-handle-events launchpad (print-handler notes))
@notes
(use 'midi)
(def launchpad (midi-in))
(def notes (atom {}))
(defn print-handler [notelog]
  (fn [event ts]
    (swap! notelog assoc :last-e event :last-ts ts)
 
    ))
      ; (or (= (:cmd event) :note-off)
      ;     (and (not (zero? (:note event)))
      ;          (zero? (:vel event))))
      ;   (if-let [note-id (get @notelog (:note event))]
      ;    (swap! notelog dissoc (:note event))) 
        ; )))
(midi-handle-events launchpad (print-handler notes))
@notes
(use 'midi)
(def launchpad (midi-in))
(def notes (atom {}))
(defn print-handler [notelog]
  (fn [event ts]
    (swap! notelog assoc :last-e event :last-ts ts)))
(midi-handle-events launchpad (print-handler notes))
@notes
(require 'main(
(require 'main)
@notes
main/@notes
main/notes
(require 'main)
@device-events
@main/device_events
main/@device_events
main/device_events
(require 'main)
main/device-events
(require 'main)
main/device-events
(require 'main)
(map #(%) [{:a 1 :b 2} {:a 3 :b 4}])
(map #(:A %) [{:a 1 :b 2} {:a 3 :b 4}])
(map #(:a %) [{:a 1 :b 2} {:a 3 :b 4}])
(map #([(:a %) %]) [{:a 1 :b 2} {:a 3 :b 4}])
(map #('[(:a %) %]) [{:a 1 :b 2} {:a 3 :b 4}])
(into {} [:a 1 :b 2])
(hash-map :a 1 :b 2)
(reduce #(conj (:a %) %) [{:a 1 :b 2} {:a 3 :b 4}])
(reduce #(conj (:a %) %) [] [{:a 1 :b 2} {:a 3 :b 4}])
(reduce #(-> %1 (conj (:a %2)) (conj %2)) [] [{:a 1 :b 2} {:a 3 :b 4}])
(hash-map (reduce #(-> %1 (conj (:a %2)) (conj %2)) [] [{:a 1 :b 2} {:a 3 :b 4}]))
(apply hash-map (reduce #(-> %1 (conj (:a %2)) (conj %2)) [] [{:a 1 :b 2} {:a 3 :b 4}]))
(def events [{:a 1 :b 2} {:a 3 :b 4}])
(->> events
    (reduce #(-> %1 (conj (:a %2)) (conj %2)) [])
    (apply hash-map)))
(->> events
    (reduce #(-> %1 (conj (:a %2)) (conj %2)) [])
    (apply hash-map))
(def r (->> events
    (reduce #(-> %1 (conj (:a %2)) (conj %2)) [])
    (apply hash-map)))
(r 1)
(require 'main)
(def device-names [:piano])
(reduce 
    #(assoc %1 %2 {})
    {}
    (device-names))
(require 'main)
(use 'midi-clj)
(use '[midi-clj])
(use '[midi])
midi-shortmessage-command
(midi-shortmessage-command)
(midi-shortmessage-command :144)
(midi-shortmessage-command :44)
(midi-shortmessage-command 144)
(assoc {:a 1} :a ({} :a))
(into {} (remove (comp nil? second) {:a 1 :b nil}))
(mod 60 12)
(mod 61 12)
(mod 62 12)
(mod 71 12)
([:a :b :c] 0)
([:a :b :c] 1)
([:a :b :c] 2)
:C#
(/ 60 12)
(/ 61 12)
(quot 61 12)
(quot 62 12)
(quot 71 12)
(quot 72 12)
(defn- midi->note [midi-note]
  (let [note-num (mod midi-note (count notes))]
    (notes note-num)))
(defn- midi->octave [midi-note]
(def notes [:C :C# :D :D# :E :F :F# :G :G# :A :A# :B ])
(defn- midi->note [midi-note]
  (let [note-num (mod midi-note (count notes))]
    (notes note-num)))
(defn- midi->octave [midi-note]
    (quot note-num (count notes)))
(defn- midi->octave [midi-note]
    (quot midi-note (count notes)))
(midi->note 60)
(midi->note 61)
(midi->note 62)
(midi->octave 62)
(require '[thi.ng.color.core :as col])
(col/as-hsv (col/rgba 255 0 0))
(col/as-hsva (col/rgba 255 0 0))
(col/as-hsva (col/rgba 255 125 0))
(col/as-hsva (col/rgba 255 255 0))
(col/as-hsva (col/rgba 125 255 0))
(col/as-hsva (col/rgba 0 255 0))
(col/as-hsva (col/rgba 0 255 125))
(col/as-hsva (col/rgba 0 255 255))
(col/as-hsva (col/rgba 0 125 255))
(col/as-hsva (col/rgba 0 0 255))
(col/as-hsva (col/rgba 125 0 255))
(col/as-hsva (col/rgba 255 0 255))
(col/as-hsva (col/rgba 255 0 125))
(conj {:a 1} {:b 2})
(merge {:a 1} {:b 2})
(require 'colours)
(def middle-c { :amp 45 :decay 40 :note 60 })
(def c (colours/note->hsv middle-c))
c
(require 'main)
(/3 2)
(/ 3 2)
(% 3 2)
(/ 3 3)
(/ 3 2)
(ns example
  (:use [uncomplicate.fluokitten core jvm]))
(fapply {a: (partial * 2)} {a: 2})
(fapply {:a (partial * 2)} {:a 2})
(fapply {:a #(* % 2)} {:a 2})
(fapply {1 {:a #(* % 2)}} {1 {:a 2}})
(op {1 {:a #(* % 2)}} {1 {:a 2}})
(fmap fapply {1 {:a #(* % 2)}} {1 {:a 2}})
(def state { :piano { 42 { :attack 70 :release 22 :note 42 }}})
(def mutators { :piano { 42 { :attack half :release half }}})
(def half #(/ % 2))
(def mutators { :piano { 42 { :attack half :release half }}})
(fmap fapply mutators state)
(fmap fmap fapply mutators state)
fmap (partial fmap fapply) mutators state)
(fmap (partial fmap fapply) mutators state)
(require 'main)
(require '[java-time :as jt])
(local-time)
(jt/local-time)
(str (jt/local-time))
(str (jt/local-datetime))
(str (jt/local-date-time))
(jt/local-date-time "2019-08-26T12:34:18.679")
(defn uuid [] (str (java.util.UUID/randomUUID)))
(uuid)
(require '[uncomplicate.fluokitten.core :as fk])
(fk/fapply {:a +} {:a 1})
(fk/fapply {:a + :b str} {:a 1})
(str)
(identity {:a 1})
(identity (:a {: 1})))
(identity (:a {:a 1}))
(identity (:a {:a {:b 2}}))
(def m {:a 1 :b 2 :c 3})
(def af identify)
(def af identity)
(def bf identity)
(def cf identity)
(def fs (juxt af bf cf))
(vs (juxt :a :b :c))
(def vs (juxt :a :b :c))
(map apply (zipmap fs vs))
(map apply (zipmap (fs) (vs)))
(zipmap (fs) (vs))
(zipmap fs vs)
(zipmap (fs) vs)
(map fs vs)
(map (fs) vs)
(map fs vs)
(map fs (vs))
(map fs (vs m))
(fs (vs m))
(- [1 2 4] [1 2 3])
(- (set [1 2 4]) (set [1 2 3]))
(if nil nil 0)
(if 1 nil 0)
(require 'main)
(def m {:a 1 :b 2}})
(def m {:a 1 :b 2})
(apply identity m)
(apply identity [m])
(require 'main)