clojure-plus

The clojure-plus project provides several namespaces to improve the Clojure standard library experience:

The clojure+.walk namespace provides a drop-in replacement for clojure.walk designed to reduce Garbage Collection (GC) pressure.

While standard clojure.walk recreates data structures even if they haven't changed, clojure+.walk (e.g., postwalk or prewalk) checks if the result of a transformation is identical? to the original. If the data hasn't changed, it reuses the existing structure. This utilizes structural sharing and is significantly more efficient for deep trees where only small parts are modified.

(let [m {:a 1, :b 2}]
  ;; Returns true because identity was preserved
  (identical? m (clojure+.walk/postwalk identity m)))

To use clojure-plus, add the following dependency to your deps.edn file:

io.github.tonsky/clojure-plus {:mvn/version "1.7.2"}

To activate the enhanced exception printing, call clojure+.error/install!. You can pass an optional configuration map as shown in the configuration guide.

To revert to the standard Clojure exception printer, call clojure+.error/uninstall!.

(clojure+.error/install!)

;; To restore default Clojure behavior
(clojure+.error/uninstall!)

The clojure+.hashp namespace provides the #p macro, a faster and more informative alternative to println. It returns the original value, allowing it to be used inline or within threading macros (->, ->>).

To use it, you must call (clojure+.hashp/install!) (recommended for dev mode).

(require '[clojure+.hashp :as hashp])
(hashp/install!)

;; Usage example
(defn f []
  (let [x 5
        y #p (+ x 2)]
    (* x y)))

;; Usage in threading macros
(-> x
    hsql/format
    #p first
    #p (sql-pretty)
    println)

The when+ macro is similar to if+, but it wraps the body in an implicit do block. You can use :let inside an and condition to make variables available in the body.

(when+ (and
         (= 1 2)
         :let [x 3
               y (+ x 4)]
         (> y x))
  
  ;; body: x and y visible here!
  (+ x y 5))

The cond+ macro extends cond with several capabilities:

• :let: Define new variables between conditions.
• :do: Insert imperative code that executes before continuing evaluation.
• :else: Standard fallback branch.
• Nested :let: Declare variables inside and conditions within a branch, making them visible to the matching branch.

;; Define variables between conditions
(cond+
  false   :false
  :let    [x 1]
  (= 1 x) (str x))

;; Insert imperative code
(cond+
  (= 1 a) :false
  :do     (println a) 
  :else   :true)

;; Declare variables inside conditions
(cond+
  (and
    (= 1 1)
    :let [x 2
          y (+ x 1)]
    (> y x))
  [x y])

The clojure+.print namespace provides cleaner, more elegant string representations for Clojure built-in datastructures, classes, and Java objects (like atom, file, ns, int-array, etc.). It also provides reader tags (e.g., #atom, #file, #ints) to make constructing these objects easier.

Warning: This representation does not track identity. Printing an atom and reading it back will produce a new object instance.

Installation:

1. (require 'clojure+.print)
2. (clojure+.print/install!)

Customization:

• (clojure+.print/install-printers! {:include ['queue 'file]})
• (clojure+.print/install-readers! {:exclude ['bytes 'ns]})

(require 'clojure+.print)
(clojure+.print/install!)

;; Example transformations
;; (atom 123) => #atom 123
;; (io/file "/") => #file "/"
;; (int-array [1 2 3]) => #ints [1 2 3]

The clojure+.test/run function replaces the confusing variety of clojure.test functions (run-tests, run-all-tests, run-test-var, run-test) with a single, unified interface.

It accepts various inputs including:

• Symbols
• Vars
• Namespaces
• Regexes

Calling it without arguments runs all tests in the project.

;; Run all tests
(clojure+.test/run)

;; Run specific tests (example usage)
(clojure+.test/run 'my-namespace.test-var)