KingCode

See
https://gist.github.com/ericnormand/7174aaccc71025de86ddac77553f8595

How many digits?

Imagine you took all the integers between n and m (exclusive, n <
m) and concatenated them together. How many digits would you have?
Write a function that takes two numbers and returns how many
digits. Note that the numbers can get very big, so it is not
possible to build the string in the general case.

KingCode

(defn frequencies-by
  "Returns a map from distinct results of (f item) in coll 
  to a vector duple of all (k item) (if k is provided, or items otherwise) 
  with the same (f item) value, and the number of times (f item) appears.
"
  ([f coll] 
   (frequencies-by f nil coll))
  ([f k coll] 
   (persistent! ;; copied from clojure.core

KingCode

(defn slow-assoc [m & [k v & kvs :as dat]]
  (if (empty? dat)
    m
    (apply slow-assoc (assoc m k v) kvs)))

(defn emit-assoc [ [ksym vsym]]
  `(assoc  ~ksym ~vsym))

(defmacro fast-assoc [msym & kvsyms]
  (let [assocs (map #(emit-assoc %) 

KingCode

(defn monoid* [init body]
  `(fn f# 
     ([] 
      (fn [& ~'xs] ~init))
     ([~'r] 
      (fn [& ~'xs] (~body (apply ~'r ~'xs))))
     ([~'r1 ~'r2] 
      (fn [& ~'xs] (~body(apply ~'r1 ~'xs) (apply ~'r2 ~'xs))))
     ([~'r1 ~'r2 & ~'rs]
      (fn [& ~'xs] 

KingCode

(ns cond-let)
;; (cond-let 
;;   (odd? x) [x n] (inc x)  
;;   (< n 10) [y (inc n)] 10
;;   :else n))

;; we want the above to yield
;; (let [x n]
;;   (if (odd? x)
;;      (inc x)

KingCode

(defn lazify [[x & xs :as coll]]
  (lazy-seq
   (when (seq coll)
     (cons x (lazify xs)))))

(def my-lazy-input (lazify [1 2 4 1 2 3 1]))
(type my-lazy-input)  ;; => clojure.lang.LazySeq
(type (rest my-lazy-input)) ;; => clojure.lang.LazySeq

;; So my-lazy-input is truly lazy all the wal...Now I want to feed it to 'sequence 

KingCode

;; see 
;; https://gist.github.com/ericnormand/81722b80fc7d0b2972fda68652489f65
(ns my-ns-test
  (:require [my-ns :as sut] 
            [clojure.test.check.properties :as prop]
            [clojure.test.check.generators :as gen]
            [clojure.test.check.clojure-test :refer [defspec]]))

(let [alias-str "sut"
      sym (symbol (str alias-str "/parallel?"))]

KingCode

(require '[clojure.core.async :as async :refer [chan <!! put!]])

(defn save-to [c save-f]
  (fn [rf] 
    (fn
      ([] (rf))
      ([acc] (rf acc))
      ([acc x]
       (put! c (save-f x))
       (rf acc x)))))

KingCode

(ns scratch.transducer
  (:refer-clojure :exclude [comp map filter mapcat take drop 
                            take-while drop-while
                            dedupe
                            distinct
                            reductions
                            ;; sequence
                            transduce]))

KingCode

(require '[clojure.spec :as s]
         '[clojure.spec.test :as stest])
               
(defn fizzbuzz 
  ([m1 m2 n]
   (let [ c #(->> % vector (concat (-> %2 dec (repeat nil))) cycle)
         fb-re #"Fizz|Buzz|FizzBuzz"]
     (->> [(c "Fizz" m1), (c "Buzz" m2)]
          (apply map 
                 (fn [i m1 m2]