### Start clojure+.core.server Socket REPL from Command Line

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This example shows how to invoke `clojure+.core.server/start-server` from the command line using `clj -X`. It highlights the improved defaults and functionality compared to the standard `clojure.core.server`, such as automatic port selection and logging.

```Shell
clj -X clojure.core.server/start-server
Execution error (IllegalArgumentException) at clojure.core.server/required (server.clj:47).
Additional data must be non-nil.

clj -X clojure+.core.server/start-server
Started Server Socket REPL on port 47844
```

--------------------------------

### Configure Clojure+ to Reverse Stack Traces

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Demonstrates how to install and configure `clojure+.error` to reverse the order of stack traces, making the exception message and origin visible at the bottom without scrolling. This snippet shows the `install!` function with the `:reverse?` option set to `true` and an example of an `Exception` being printed, which would then display the reversed stack trace.

```Clojure
(clojure+.error/install! {:reverse? true})
(println (Exception. "Oops"))
```

--------------------------------

### Basic Installation of clojure+.print Library

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Provides the minimal Clojure code required to install and enable the `clojure+.print` library. Executing these lines makes its improved printing and reader tag functionalities available for immediate use.

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

--------------------------------

### Install Clojure #p Debugging Macro

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

To enable the `#p` debugging macro, you need to call `(clojure+.hashp/install!)`. It is recommended to do this only in development environments (e.g., `dev/user.clj`) to prevent accidental inclusion in production builds.

```clojure
(clojure+.hashp/install!)
```

--------------------------------

### Enable clojure+.test for Enhanced Reporting

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This snippet demonstrates how to install `clojure+.test` to enhance the reporting output of `clojure.test`. It relies on `clojure.test` for test definition but improves the display of results.

```Clojure
(clojure+.test/install!)
```

--------------------------------

### Selective Installation of clojure+.print Features

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Demonstrates how to selectively install `clojure+.print` features using `:include` and `:exclude` options for printers and readers. This allows fine-grained control over which custom print representations or reader tags are enabled.

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

--------------------------------

### Clojure+ Supported Function Types

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Provides examples of tagged literal forms for Clojure function types, including `AFunction` and `MultiFn`.

```Clojure
AFunction             #fn clojure.core/+
                      #fn clojure+.print/fn--25647/f1--25648
MultiFn               #multifn print-method
```

--------------------------------

### Clojure #p Debugging Macro in Threading Macros

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This example highlights `#p`'s utility within `->` (thread-first) and `->>` (thread-last) macros. It allows for easy inspection of intermediate values in a threading chain without breaking the flow or requiring complex `println` insertions.

```clojure
(-> x
    hsql/format
    #p first        ;; <-- just add it like this
    #p (sql-pretty) ;; <-- or like this
    println)
```

--------------------------------

### Clojure cond+ Macro with Intermediate Variable Declaration

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This `cond+` example shows how to declare new variables using `:let` between conditions. These variables are then available for use in subsequent conditions and their corresponding branches, providing more flexible conditional logic than standard `cond`.

```clojure
(cond+
  false   :false
  :let    [x 1]
  (= 1 x) (str x)) ; => \"1\"
```

--------------------------------

### Clojure cond+ Macro with In-Condition Variable Declaration

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This example demonstrates how `cond+` supports declaring variables within an `and` condition using `:let`, similar to `if+`. These variables are visible within the same condition and its matching branch, allowing for complex, self-contained conditional logic.

```clojure
(cond+
  (and
    (= 1 1)
    ;; declare new vars inside `and` condition
    :let [x 2
          y (+ x 1)]
    ;; use them downstream in the same condition
    (> y x))
  ;; matching branch sees them too
  [x y]) ;; => [2 3]
```

--------------------------------

### Clojure if+ Macro with Shared Local Variables

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This example demonstrates the `if+` macro, which allows sharing local variables declared with `:let` within an `and` condition. These variables become visible in subsequent `and` clauses and the `then` branch, simplifying complex conditional logic that would otherwise require duplicating `else` clauses.

```clojure
(if+ (and
       (= 1 2)
       ;; same :let syntax as in doseq/for
       :let [x 3
             y (+ x 4)]
       ;; x and y visible downstream
       (> y x))
  
  ;; “then” branch: x and y visible here!
  (+ x y 5)
  
  ;; “else” branch: no x nor y
  6)
```

--------------------------------

### Clojure+.test Run Function API Reference

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Documents the `clojure+.test/run` function, which unifies various test execution functions from `clojure.test` into a single, flexible entry point. It accepts symbols, vars, namespaces, and regexes, and runs all tests if called without arguments, simplifying test execution.

```APIDOC
clojure+.test/run
  description: Replaces clojure.test's run-tests, run-all-tests, run-test-var, and run-test with a single, unified function.
  parameters:
    args: (optional) Can be symbols, vars, namespaces, or regexes.
  behavior:
    - When called without arguments, it runs all tests.
    - Makes test runs interruptible, addressing limitations in clojure.test.
```

--------------------------------

### Clojure+.test Namespace and Total Time Reporting

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Shows how `clojure+.test` provides detailed timing information for each namespace tested, along with a summary of total tests, assertions, failures, and errors, offering a comprehensive overview of test run performance.

```Clojure
18/21 Testing instant.storage.sweeper-test... 11584 ms
19/21 Testing instant.util.hazelcast-test... 7 ms
20/21 Testing instant.util.semver-test... 1 ms
21/21 Testing instant.util.uuid-test... 126 ms
╶───╴
Ran 49 tests containing 450 assertions in 19082 ms.
9 failures, 2 errors.
```

--------------------------------

### Default Configuration Options for Clojure+ Error Reporting

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Presents the default configuration map used by `clojure+.error/install!`. This snippet details various options such as cleaning stack traces, collapsing common frames, enabling color, and indentation, providing a comprehensive overview of customization possibilities for error output.

```Clojure
(clojure+.error/install!
  {:clean?           true
   :collapse-common? true
   :trace-transform  nil
   :color?           true
   :reverse?         false
   :root-cause-only? false
   :indent           2})
```

--------------------------------

### Simplifying Object Construction with clojure+.print Reader Tags

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Illustrates how `clojure+.print` introduces custom reader tags (`#path`, `#queue`) to simplify the construction of `java.nio.file.Path` and `clojure.lang.PersistentQueue` objects. This significantly reduces boilerplate compared to traditional Clojure syntax.

```Clojure
; before
(java.nio.file.Path/of "/" (make-array String 0))
(into clojure.lang.PersistentQueue/EMPTY [1 2 3])

; after
#path "/"
#queue [1 2 3]
```

--------------------------------

### Default Clojure Exception Output Format

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Demonstrates the verbose and difficult-to-parse default exception output in Clojure, highlighting issues like redundant information, unclear labels, and deep nesting that make debugging challenging.

```Clojure
user=> (println (Exception. "Oops"))
#error {
 :cause Oops
 :via
 [{:type java.lang.Exception
   :message Oops
   :at [user$eval3 invokeStatic NO_SOURCE_FILE 1]}]
 :trace
 [[user$eval3 invokeStatic NO_SOURCE_FILE 1]
  [user$eval3 invoke NO_SOURCE_FILE 1]
  [clojure.lang.Compiler eval Compiler.java 7700]
  [clojure.lang.Compiler eval Compiler.java 7655]
  [clojure.core$eval invokeStatic core.clj 3232]
  [clojure.core$eval invoke core.clj 3228]
  [clojure.main$repl$read_eval_print__9244$fn__9247 invoke main.clj 437]
  [clojure.main$repl$read_eval_print__9244 invoke main.clj 437]
  [clojure.main$repl$fn__9253 invoke main.clj 459]
  [clojure.main$repl invokeStatic main.clj 459]
  [clojure.main$repl_opt invokeStatic main.clj 523]
  [clojure.main$main invokeStatic main.clj 668]
  [clojure.main$main doInvoke main.clj 617]
  [clojure.lang.RestFn invoke RestFn.java 400]
  [clojure.lang.AFn applyToHelper AFn.java 152]
  [clojure.lang.RestFn applyTo RestFn.java 135]
  [clojure.lang.Var applyTo Var.java 707]
  [clojure.main main main.java 40]]}
```

--------------------------------

### Displaying Clojure+ ExceptionInfo Details

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Illustrates how `clojure+.error` handles `ExceptionInfo` instances, ensuring that the associated data map is also displayed along with the exception message when printed. This shows the enhanced output for `ex-info`.

```Clojure
(println (ex-info "Oops" {:a 1, :b 2}))
```

--------------------------------

### Compare Clojure.test and Clojure+.test Failure Output

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Illustrates the difference in test failure reporting between the default `clojure.test` and the enhanced `clojure+.test`. The improved version provides structured context, separate expected/actual values, and includes the namespace in the test name for clearer debugging.

```Clojure
(deftest test-name
  (testing "namespaces"
    (testing "all-ns"
      (is (= 0 (count (all-ns)))))))
```

```Clojure
FAIL in (test-name) (test_ns.clj:123)
namespaces all-ns
expected: (= 0 (count (all-ns)))
  actual: (not (= 0 675))
```

```Clojure
FAIL in test-ns/test-name (test_ns.clj:123)
└╴namespaces
  └╴all-ns
    ├╴form:     (= 0 (count (all-ns)))
    ├╴expected: 0
    └╴actual:   675
```

--------------------------------

### Add Clojure Plus to deps.edn

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This snippet shows how to include the Clojure Plus library in your project by adding it as a dependency in your `deps.edn` file. Specify the `io.github.tonsky/clojure-plus` artifact with its version to integrate the library.

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

--------------------------------

### Clojure+ Readable Exception Output with prn

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Demonstrates Clojure+'s ability to print exceptions in a format that is both human-readable and machine-readable (parseable by Clojure's `read` function) using `prn`, while maintaining good formatting.

```Clojure
user=> (prn (Exception. "Oops"))

#error {
 :class   java.lang.Exception
 :message "Oops"
 :trace
 [[user/eval]
  [Compiler.eval                         "Compiler.java" 7700]
  [Compiler.eval                         "Compiler.java" 7655]
  [clojure.core/eval                     "core.clj" 3232]
  [clojure.main/repl/read-eval-print/fn  "main.clj" 437]
  [clojure.main/repl/read-eval-print     "main.clj" 437]
  [clojure.main/repl/fn                  "main.clj" 459]
  [clojure.main/repl                     "main.clj" 459]
  [clojure.main/repl-opt                 "main.clj" 523]
  [clojure.main/main                     "main.clj" 668]
  [Var.applyTo                           "Var.java" 707]
  [main.main                             "main.java" 40]]}
```

--------------------------------

### Clojure+ Enhanced Exception Output

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Illustrates the significantly improved and more readable exception stack trace generated by Clojure+, featuring cleaned-up, Clojure-aware formatting that decodes stack trace elements into familiar Clojure forms.

```Clojure
user=> (println (Exception. "Oops"))
Exception: Oops
  user/eval
  Compiler.eval                         Compiler.java 7700
  Compiler.eval                         Compiler.java 7655
  clojure.core/eval                     core.clj 3232
  clojure.main/repl/read-eval-print/fn  main.clj 437
  clojure.main/repl/read-eval-print     main.clj 437
  clojure.main/repl/fn                  main.clj 459
  clojure.main/repl                     main.clj 459
  clojure.main/repl-opt                 main.clj 523
  clojure.main/main                     main.clj 668
  Var.applyTo                           Var.java 707
  main.main                             main.java 40
```

--------------------------------

### Java's printStackTrace Output for Comparison

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Presents the cleaner and more concise exception stack trace format provided by Java's `printStackTrace` method, often used by Clojure developers for better clarity compared to Clojure's default output.

```Clojure
user=> (.printStackTrace (Exception. "Oops"))
java.lang.Exception: Oops
        at user$eval5.invokeStatic(NO_SOURCE_FILE:1)
        at user$eval5.invoke(NO_SOURCE_FILE:1)
        at clojure.lang.Compiler.eval(Compiler.java:7700)
        at clojure.lang.Compiler.eval(Compiler.java:7655)
        at clojure.core$eval.invokeStatic(core.clj:3232)
        at clojure.core$eval.invoke(core.clj:3228)
        at clojure.main$repl$read_eval_print__9244$fn__9247.invoke(main.clj:437)
        at clojure.main$repl$read_eval_print__9244.invoke(main.clj:437)
        at clojure.main$repl$fn__9253.invoke(main.clj:459)
        at clojure.main$repl.invokeStatic(main.clj:459)
        at clojure.main$repl_opt.invokeStatic(main.clj:523)
        at clojure.main$main.invokeStatic(main.clj:668)
        at clojure.main$main.doInvoke(main.clj:617)
        at clojure.lang.RestFn.invoke(RestFn.java:400)
        at clojure.lang.AFn.applyToHelper(AFn.java:152)
        at clojure.lang.RestFn.applyTo(RestFn.java:135)
        at clojure.lang.Var.applyTo(Var.java:707)
        at clojure.main.main(main.java:40)
```

--------------------------------

### Improved Clojure Printing with clojure+.print

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Shows the cleaner and more readable output for common Clojure data structures (Atom, File, Namespace, TransientVector) when using the `clojure+.print` library. This contrasts sharply with the default verbose output, providing immediate clarity.

```Clojure
=> (atom 123)
#atom 123

=> (io/file "/")
#file "/"

=> *ns*
#ns user

=> (transient [1 2 3])
#transient [1 2 3]
```

--------------------------------

### Clojure #p Debugging Macro Basic Usage

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This snippet shows the basic usage of the `#p` debugging macro. Instead of `println`, `#p` can be placed directly around an expression to print its value, along with its location and form, without altering the expression's return value or introducing extra nesting.

```clojure
(defn f []
  (let [x 5
        y #p (+ x 2)]
    (* x y)))
```

--------------------------------

### Clojure Default Printing (Pre-1.7)

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Illustrates the default string representation of common Clojure data structures like Atom, File, and Namespace before Clojure 1.7. This shows a more compact output compared to later versions, highlighting the historical printing behavior.

```Clojure
=> (atom 42)
#<Atom@2fc0cc3: 42>

=> (io/file "/")
#<File />

=> *ns*
#<Namespace user>
```

--------------------------------

### Clojure+ Supported Miscellaneous Types

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Covers tagged literal forms for other common Java types like `File`, `Path`, `Namespace`, `Thread`, `InetAddress`, `URL`, `URI`, `TimeUnit`, and `Charset`.

```Clojure
File                  #file "/"
Path                  #path "/"
Namespace             #ns clojure+.print
Thread                #thread [35 "clojure-agent-send-off-pool-1"]
                      ^:virtual #thread [36 "vvv"]
InetAddress           #inet-address "127.0.0.1"
                      #inet-address "1080:0:0:0:8:800:200c:417a"
URL                   #url "https://example.com"
URI                   #uri "https://example.com"
TimeUnit              #time-unit :seconds
Charset               #charset "UTF-8"
```

--------------------------------

### Enhanced Array Printing with clojure+.print

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Compares the default verbose printing of Clojure arrays with the concise and readable output provided by the `clojure+.print` library. Specifically, it highlights the transformation of `int-array` representations for better readability.

```Clojure
user=> (int-array [1 2 3])
; before
#object["[I" 0x595f4da5 "[I@595f4da5"]
; after
#ints [1 2 3]
```

--------------------------------

### Compare Data Structure Identity Preservation with clojure.walk vs clojure+.walk

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This snippet demonstrates the difference in data structure identity preservation between `clojure.walk/postwalk` and `clojure+.walk/postwalk`. While `clojure.walk` always recreates structures, `clojure+.walk` reuses existing ones if no changes occur, leading to better GC performance and structural sharing.

```Clojure
(let [m {:a 1, :b 2}]
  (identical? m (clojure.walk/postwalk identity m)))

;; (into (empty m) (map identity m))
; => false
```

```Clojure
(let [m {:a 1, :b 2}]
  (identical? m (clojure+.walk/postwalk identity m)))

; => true
```

--------------------------------

### Clojure Default Printing (Post-1.7 Verbose)

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Demonstrates the verbose default string representation of Clojure data structures like Atom, File, Namespace, and TransientVector introduced in Clojure 1.7. This change resulted in a significantly noisier output for many core types.

```Clojure
=> (atom 123)
#object[clojure.lang.Atom 0x23c650a3 {:status :ready, :val 123}]

=> (io/file "/")
#object[java.io.File 0x7d2a6eac "/"]

=> *ns*
#object[clojure.lang.Namespace 0x3961a41a "user"]

=> (transient [1 2 3])
#object[clojure.lang.PersistentVector$TransientVector 0x41c89d2f "clojure.lang.PersistentVector$TransientVector@41c89d2f"]
```

--------------------------------

### Clojure+ Supported Reference Types

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Illustrates the tagged literal forms for various Clojure and Java reference types, such as `Atom`, `Agent`, `Ref`, `Volatile`, `Reduced`, `Promise`, `Delay`, `Future`, `SoftReference`, `WeakReference`, and different `Atomic` types.

```Clojure
Atom                  #atom 123
Agent                 #agent 123
Ref                   #ref 123
Volatile              #volatile 123
Reduced               #reduced 123
Promise               #promise <pending...>
                      #promise 123
Delay                 #delay <pending...>
                      #delay 123
Future                #future <pending...>
                      #future 123
SoftReference         #soft-ref #object[...]
WeakReference         #weak-ref #object[...]
AtomicBoolean         #atomic-boolean true
AtomicInteger         #atomic-int 123
AtomicLong            #atomic-long 123
AtomicReference       #atomic-ref #object[...]
AtomicIntegerArray    #atomic-ints [1 2 3]
AtomicLongArray       #atomic-longs [1 2 3]
AtomicReferenceArray  #atomic-refs [#object[...] ...]
```

--------------------------------

### Clojure+.test Uncaught Exception Location Reporting

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Demonstrates how `clojure+.test` reports the exact line within the test where an uncaught exception occurred, rather than just the origin of the exception in the called function, significantly aiding in pinpointing the source of test failures.

```Clojure
(defn f []
  (throw (Exception.))) ;; <-- Clojure will report this

(deftest t
  (f)) ;; <-- we are reporting this

(clojure+.test/run #'t)
```

```Clojure
ERROR in file/t (file.clj:5) ;; <-- here
└╴uncaught: ...
```

--------------------------------

### Clojure+ Supported Data Structures

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Shows tagged literal representations for common Clojure data structures like `PersistentQueue` and `Transients` (for vectors, maps, and sets).

```Clojure
PersistentQueue       #queue [1 2 3]
Transients            #transient [1 2 3]
                      #transient {:a 1 :b 2}
                      #transient #{:a :b :c}
```

--------------------------------

### Clojure+.test Filtered Exception Stack Traces

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Compares the verbose default `clojure.test` exception stack trace with the filtered version provided by `clojure+.test`, which removes irrelevant `clojure.test` machinery frames for clearer and more concise debugging of test failures.

```Clojure
ERROR in instant.db.instaql-test/some-test (Numbers.java:123)
└╴abc
  └╴def
    ├╴expected: (pos? "caught")
    └╴actual:   ClassCastException: class java.lang.String cannot be cast to class java.lang.Number (java.lang.String and java.lang.Number are in module java.base of loader 'bootstrap')
  Numbers.isPos                                 Numbers.java 123
  clojure.core/pos?                             core.clj 1266
  clojure.core/apply                            core.clj 667
  instant.db.instaql-test/fn/fn                 instaql_test.clj 2509
  instant.db.instaql-test/fn                    instaql_test.clj 2509
  clojure.test/test-var/fn                      test.clj 717
  clojure.test/test-var                         test.clj 717
  clojure+.test/run/fn/fn                       test.clj 224
  clojure.test/default-fixture                  test.clj 687
  clojure+.test/run/fn                          test.clj 222
  clojure.test/default-fixture                  test.clj 687
  clojure+.test/run                             test.clj 218
  user/test-all                                 user.clj 25
  user/eval
  Compiler.eval                                 Compiler.java 7700
  clojure-sublimed.socket-repl/eval-code/fn
  clojure-sublimed.socket-repl/eval-code
  clojure-sublimed.socket-repl/fork-eval/fn/fn
  clojure-sublimed.core/track-vars*
  clojure-sublimed.socket-repl/fork-eval/fn
  clojure.core/binding-conveyor-fn/fn           core.clj 2047
  FutureTask.run                                FutureTask.java 317
  ThreadPoolExecutor.runWorker                  ThreadPoolExecutor.java 1144
  ThreadPoolExecutor$Worker.run                 ThreadPoolExecutor.java 642
  Thread.run                                    Thread.java 1570
```

```Clojure
ERROR in instant.db.instaql-test/some-test (Numbers.java:123)
└╴abc
  └╴def
    ├╴expected: (pos? "caught")
    └╴actual:   ClassCastException: class java.lang.String cannot be cast to class java.lang.Number (java.lang.String and java.lang.Number are in module java.base of loader 'bootstrap')
  Numbers.isPos                  Numbers.java 123
  clojure.core/pos?              core.clj 1266
  clojure.core/apply             core.clj 667
  instant.db.instaql-test/fn/fn  instaql_test.clj 2509
  instant.db.instaql-test/fn     instaql_test.clj 2509
```

--------------------------------

### Clojure if+ Macro for Optional Binding and Condition

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

This snippet illustrates how `if+` can be used to conditionally bind a variable and then use it in a subsequent condition. This pattern is useful for handling cases where a value might be present, and further logic depends on its properties, avoiding nested `if` and `let` forms.

```clojure
(if+ (and
       (some? x)
       :let [f (.-f x)]
       (= :... f))
  ...)
```

--------------------------------

### Clojure cond+ Macro with Imperative Code Insertion

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

The `cond+` macro allows inserting imperative code blocks using `:do` between conditions. This code will execute before the evaluation continues to the next condition, enabling side effects or logging within the conditional flow.

```clojure
(cond+
  (= 1 a) :false
  :do     (println a) ; will print 1 before continuing evaluating
  :else   :true)
```

--------------------------------

### Restore Default Clojure Error Printer

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Shows how to uninstall `clojure+.error` and revert to the default Clojure error printing behavior. This is useful for disabling the custom error reporting enhancements provided by the library.

```Clojure
(clojure+.error/uninstall!)
```

--------------------------------

### Clojure when+ Macro with Shared Local Variables

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Similar to `if+`, the `when+` macro allows sharing local variables declared with `:let` within an `and` condition. The body of `when+` is implicitly wrapped in a `do` block, and the `:let`-declared variables are visible within this body.

```clojure
(when+ (and
         (= 1 2)
         ;; same :let syntax as in doseq/for
         :let [x 3
               y (+ x 4)]
         ;; x and y visible downstream
         (> y x))
  
  ;; body: x and y visible here!
  (+ x y 5))
```

--------------------------------

### Clojure+ Supported java.time Types

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Details the tagged literal representations for various `java.time` classes, such as `Duration`, `Instant`, `LocalDate`, `LocalDateTime`, `LocalTime`, `MonthDay`, `OffsetDateTime`, `OffsetTime`, `Period`, `Year`, `YearMonth`, `ZonedDateTime`, `ZoneId`, `ZoneOffset`, `DayOfWeek`, `Month`, and `ChronoUnit`.

```Clojure
Duration              #duration "PT12H30M59S"
Instant               #instant "2025-02-20T02:58:07.703Z"
LocalDate             #local-date "2025-02-20"
LocalDateTime         #local-date-time "2025-02-20T02:58:07.703"
LocalTime             #local-time "02:58:07.703"
MonthDay              #month-day "--02-29"
OffsetDateTime        #offset-date-time "2025-02-20T02:58:07.703Z"
OffsetTime            #offset-time "02:58:07.703Z"
Period                #period "P2Y3M4D"
Year                  #year 2025
YearMonth             #year-month "2025-02"
ZonedDateTime         #zoned-date-time "2025-02-20T02:58:07.703+01:00[Europe/Berlin]"
ZoneId                #zone-id "Europe/Berlin"
ZoneOffset            #zone-offset "+03:45"
DayOfWeek             #day-of-week :wednesday
Month                 #month :february
ChronoUnit            #chrono-unit :seconds
```

--------------------------------

### Clojure+ Supported Array Types

Source: https://github.com/tonsky/clojure-plus/blob/main/README.md

Demonstrates the tagged literal representations for various primitive and object array types in Clojure+, including `byte[]`, `boolean[]`, `char[]`, `short[]`, `int[]`, `long[]`, `float[]`, `double[]`, `String[]`, `Object[]`, and generic `Object` arrays.

```Clojure
byte[]                #bytes "CAFEBABE"
boolean[]             #booleans [true false]
char[]                #chars [\a \b \c]
short[]               #shorts [1 2 3]
int[]                 #ints [1 2 3]
long[]                #longs [1 2 3]
float[]               #floats [1.0 2.0 3.5]
double[]              #doubles [1.0 2.0 3.5]
String[]              #strings ["a" "b" "c"]
Object[]              #objects [nil nil]
Other arrays          #array ^java.io.File/1 [#file ...]
                      #array ^String/2 [["a"] ["b" "c"]]
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.