luxbock

{:user
  :dependencies [[im.chit/vinyasa "0.2.2"]
                 ;; ...
                 [leiningen #=(leiningen.core.main/leiningen-version)]]
  :injections [(require '[vinyasa.inject :as inject]
                         ;; other requires
                         )
               (inject/in

                 ;; Inject as is

luxbock

(ns freactive-datascript.core
  (:require [datascript :as d]
            [datascript.core :as dc]
            [clojure.data :as data]
            [freactive.core :as f :refer [IReactive
                                          *invalidate-rx*
                                          *trace-capture*]]))

;;; Playground ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

luxbock

(defn breadth-first-search [z]
  (letfn [(zip-children [loc]
            (when-let [first-child (zip/down loc)]
              (take-while (comp not nil?)
                (iterate zip/right first-child))))])
  (loop [ret []
         queue (conj clojure.lang.PersistentQueue/EMPTY z)]
    (if (seq queue)
      (let [[node children] ((juxt zip/node zip-children) (peek queue))]
        (recur (conj ret node) (into (pop queue) children)))

luxbock

;; Given that:
(destructure
  '[[f [a b] {:keys [c d]} & rs]
    [:first [:a 1 :b 2] {:c "C" :d "D"} 3 4 5]])

;; =>
[vec__22487 [:first [:a 1 :b 2] {:c "C", :d "D"} 3 4 5]
 f          (clojure.core/nth vec__22487 0 nil)
 vec__22488 (clojure.core/nth vec__22487 1 nil)
 a          (clojure.core/nth vec__22488 0 nil)

luxbock

(ns debug-walker.core
  (:refer-clojure :exclude [read-string])
  (:require [clojure.java.io :as io]
            [clojure.repl :as repl]
            [clojure.tools.reader :refer [read-string]]
            [clojure.pprint :refer [pprint]]
            [rewrite-clj.zip :as z])
  (:import [java.io LineNumberReader InputStreamReader PushbackReader]))

(defn file-source-fn

luxbock

(filter even? (range 10))

;; equals

(new clojure.lang.LazySeq
  (fn []
    (when-let
        [s (. clojure.lang.RT
             (seq (new clojure.lang.LazySeq
                    #(let [b (clojure.lang.ChunkBuffer. 32)

luxbock

(defn C [n]
  (cond
    (one? n) 1
    (even? n) (C (div n 2))
    :else (C (add1 (times 3 n)))))

(defn C* [n]
  (cond
    (= 1 n) 1
    (clojure.core/even? n) (C (quot n 2))

luxbock

(defn C
  [n]
  (cond
    (one? n) 1
    (even? n) (C (div n 2))
    :else (C (add1 (times 3 n)))))

(defn C* [n]
  (cond
    (= 1 n) 1

luxbock

(ns little-schemer.benchmark
  "Benchmarking the function C of the Collatz Conjencture:

  http://en.wikipedia.org/wiki/Collatz_conjecture

  in regular Clojure (C*) and as it is defined in the book The Little Schemer,
  where all of the parts are defined recursively in terms of add1 and sub1."
  (:gen-class)
  (:refer-clojure :exclude [even?])
  (:require [criterium.core :refer [quick-bench]]))

luxbock

(ns rdp-214.core
  (:require [clojure.java.io :as io]
            [clojure.string :as str]
            [clojure.core.typed :as t
             :refer [ann U Seq Str Vec Sequential]]))

;;;; Boilerplate ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(t/tc-ignore