Solaxun

data = open('day1.txt').read().splitlines()
data = [int(a) for a in data]

cnt = 0
for a,b in zip(data,data[1:]):
    if b > a:
        cnt += 1

print(cnt)

Solaxun

(ns tetris.game)

(def rows 20)
(def cols 10)
(def board (vec (repeat rows (vec (repeat cols  " ")))))

(defn new-game-state []
  {:board board
   :active-piece nil
   :game-over? false

Solaxun

(def game {:player1 [26 8 2 17 19 29 41 7 25 33 50 16 36 37 32 4 46 12 21 48 11 6 13 23 9],
           :player2 [27 47 15 45 10 14 3 44 31 39 42 5 49 24 22 20 30 1 35 38 18 43 28 40 34]})
;; Treating the seen rule as needing to see the exact game (both decks) twice.
;; Doesn't terminate.
(defn play-round [game]
  (loop [seen #{}
         {:keys [player1 player2] :as game} game]
    (if (or (empty? player1) (empty? player2))
      game
      (let [p1 (player1 0)

Solaxun

(defmulti destruct-type
  (fn [binding value]
    (cond (sequential? binding) clojure.lang.Sequential ; order matters, vector is associative too
          (associative? binding) clojure.lang.Associative
          :else (type binding))))

(defn coerce-binding-type [binding-type]
  (case binding-type
    :strs str
    :syms (fn [sym] `'~sym)

Solaxun

(def protos (atom nil))

(defn build-func [[name args body]]
 (list 'fn name args body))

(defmacro bleh [fbody]
  `(let [f# ~(build-func fbody)]
    (do (reset! protos f#) f#)))

(macroexpand-1 '(bleh (foo [y] (+ x y))))

Solaxun

;;;
;;; implementation
;;;
(defn build-fn [[mname args body]]
   {(keyword mname) (list 'fn mname args body)})

(defn make-generic-fn [[mname args body]]
 `(defn ~mname ~args 
   (let [f# (get ~(first args) ~(keyword mname))]
    (f# ~@args))))

Solaxun

;;;; machinery for multimethods
(defmacro defmethod2 [fname dispatch-val signature body]
  `(swap! ~(symbol (str "multimethod-lkp-" fname)) assoc ~dispatch-val 
           (fn ~signature ~body)))

(defn make-generic-fn [fname dispatchfn]
 `(defn ~fname [& ~'args] 
   (let [dispatch-val# (apply ~(symbol (str "multimethod-dispatch-" fname)) ~'args)
         mm-table# (deref ~(symbol (str "multimethod-lkp-" fname)))
         matching-fn# (some #(get mm-table# %) [dispatch-val# :default])]

Solaxun

(comment
  Multimethods are an open dispatch mechanism, but is closed in it's
  dispatch function.  If the set of dispatch types is open, so is
  the multimethod.

  Protocols are always open because you can always add a new type.
  Multimethods require you to pick something to dispatch on that
  remains open so any user can create a new one.

  For dependency injection, protocols work great because you can

Solaxun

;; couldn't resist after hearing the podcast...

(defn ibid [coll]
 (reduce (fn [res cur] 
           (if (= cur "ibid")
             (conj res (last res))
             (conj res cur)))
  [(first coll)]
  (rest coll)))

Solaxun

(def NIL (symbol "NIL"))

(deftype ConsCell [CAR CDR]
  clojure.lang.ISeq
  (cons [this x] (ConsCell. x this))  
  (first [this] (.CAR this))
  ;; next and more must return ISeq:
  ;; https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/ISeq.java
  (more [this] (if
                 (= (.CDR this) NIL)