madstap

(ns golf.code-golfer)

(def ^:private safe-neighbors
  "The characters that indicate neighboring spaces are safe to remove."
  (set "(){}[]\""))

(defn- whitespace? [x]
  {:pre [(char? x)]}
  (Character/isWhitespace x))

madstap

;; In core.cljs
(ns foo.core
  (:require
    [pushy.core :as pushy]
    [re-frame.core :as rf]]))

(defn routing! []
  (pushy/start! (pushy/pushy #(rf/dispatch [:routes/set-page %]) routes/match)))

(defn ^:export init []

madstap

Magit squashing http://www.howardism.org/Technical/Emacs/magit-squashing.html

Splitting commits https://stackoverflow.com/questions/1440050/how-to-split-last-commit-into-two-in-git/1440200 https://embeddedartistry.com/blog/2018/2/19/code-cleanup-splitting-up-git-commits-in-the-middle-of-a-branch https://stackoverflow.com/questions/6217156/break-a-previous-commit-into-multiple-commits https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History

Make git forget about a file that was tracked, but is now in gitignore

madstap

#/bin/sh

# https://askubuntu.com/questions/799414/how-to-move-files-from-ubuntu-to-iphone


idevicepair pair

# Will exit with an error if there's a password on the device
# so unlock the device,
# then it will error again, but open a dialogue on the device.

madstap

(defn merge-consecutive-by-with-xf ; this name is less than ideal...
  "Returns a transducer that reduces merge-fn over consecutive values for which
  (consecutive-by value) is the same."
  [consecutive-by merge-fn]
  (fn [rf]
    (let [prev (atom ::none)]
      (fn
        ([] (rf))
        ([res]
         (let [p @prev]

madstap

(defn merge-consecutive-by-with-xf ; this name is less than ideal...
  "Returns a transducer that reduces merge-fn over consecutive values for which
  (consecutive-by value) is the same."
  [consecutive-by merge-fn]
  (fn [rf]
    (let [prev (atom ::none)]
      (fn
        ([] (rf))
        ([res]
         (let [p @prev]

madstap

(ns foo.bool-diff
  "Have you ever wondered \"Can I write this boolean expression like that instead?\"
  Well, I have. So I wrote this to verify whether I'm right.

  Say I've got the expression:

  (and (not (foo? x))
       (not (bar? y)))

  I might think \"Isn't that the same as negating an or?\"

madstap

(defmacro when-letp
  {:style/indent 2}
  [pred bindings & body]
  (if (empty? bindings)
    `(do ~@body)
    (let [[[binding expr] more] (split-at 2 bindings)]
      `(let [temp# ~expr
             pred# ~pred]
         (when (pred# temp#)
           (let [~binding temp#]

madstap

;; Reducing function:
;;   A function that takes an accumulator and an item and returns a new accumulator.
;;   Like the function you would pass to reduce.

;; Transducer:
;;   A function that takes a reducing function and
;;   returns a new reducing function.


;; Slightly simplified, this is the meat of map with arity one.

madstap

(ns car
  "The sixties are back!"
  (:require
   [clojure.math.combinatorics :as combo]))

(defn ad-combos [n]
  (distinct
   (mapcat (fn [i]
             (combo/selections '[a d] i))
           (range 1 (inc n)))))