bsless

d = dict(a=1, b=2, c=3)
# it really should not be that weird
list(map(lambda k, v: (k, 2*v), *zip(*d.items())))

bsless

(defun mpv-play-url (url &rest args)
  ""
  (interactive)
  (start-process "mpv" nil "mpv" url))

(setq browse-url-browser-function
  (quote
    (("youtu\\.?be" . mpv-play-url)
    ("." . eww-browse-url))))

bsless

Seems like when using a logic db in core.logic most of the CPU cicles are spent on manipulating the thead bindings the *logic-dbs* dynamic var. However, it is only used as a wrapper when calling the underlying -run macro. Invoking it directly speeds things up significantly

Let's set up some dummy data:

(require
 '[clojure.core.logic.pldb :as pldb]

bsless

(ns clj-seperate-bench.core
  (:gen-class)
  (:require
   [criterium.core :as c]))

;;; Run with:
;;; java -Xmx8G -Xms8G -XX:+UseG1GC -jar target/uberjar/clj-seperate-bench-0.1.0-SNAPSHOT-standalone.jar

;; 54, 60 ms range
;; 54, 34 ms vector

bsless

(defn camel->snake
  [s]
  (-> s
      (clojure.string/replace #"([^_A-Z])([A-Z])" "$1-$2")
      clojure.string/lower-case))

(defn gen-param*
  [c]
  (->
   c

bsless

(defn camel->snake
  [s]
  (-> s
      (clojure.string/replace #"([^_A-Z])([A-Z])" "$1-$2")
      clojure.string/lower-case))

(defn gen-param*
  [c]
  (->
   c

bsless

(defn get-lens [k] (fn [m] (get m k)))

(defn get-in-lens
  [ks]
  (reduce
   (fn [f k]
     (fn [m]
       (let [lens (get-lens k)]
         (lens (f m)))))
   identity

bsless

(defn dissoc-in
  [m ks]
  (let [[k & ks] ks]
    (if ks
      (let [found (find m k)]
        (if found
          (assoc m k (dissoc-in (val found) ks))
          m))
      (dissoc m k))))

bsless

(defmacro cond*
  [& clauses]
  (when clauses
    (let [p (first clauses)
          return? (:return (meta p))]
      (if return?
        `(if ~p
           ~p
           (cond* ~@(next clauses)))
        `(if ~p

bsless

(defn map-or-vec?
  [x]
  (or (map? x) (vector? x)))

;;; https://www.reddit.com/r/Clojure/comments/7wl7nt/get_a_list_of_all_paths_in_a_nested_map/

(defn paths
  ([m]
   (paths [] [] m))
  ([ps ks m]