[renovate]

This PR contains the following updates:

Package	Type	Update	Change
org.clojure:clojure (source)	dependencies	minor	1.10.3 → 1.12.6

---

Warning

Some dependencies could not be looked up. Check the Dependency Dashboard for more information.

---

Release Notes

clojure/clojure (org.clojure:clojure)

v1.12.6

• CLJ-2794 - gen-class - incorrectly treats interface default methods as abstract, throwing when the var delegate is unbound
• CLJ-2974 - FnLoaderThunk - de/serialization no longer supported, throw

v1.12.5

• CLJ-2945 - reify - incorrectly transfers reader metadata to runtime object
• CLJ-2228 - constantly - unroll to remove rest args allocation

v1.12.4

• CLJ-2924 - LazySeq - fix visibility issues with non-volatile reads

v1.12.3

• CLJ-2919 - Compiler - fix nested compilation emitting for keyword and protocol call sites

v1.12.2

• CLJ-2914 - Compiler - syntax error if qualified instance method expression is missing instance
• CLJ-1798 - Refs - avoid creating RetryEx in LockingTransaction on every transaction
• CLJ-2916 - LazySeq - realize before serializing and do not serialize IFn
• CLJ-2917 - Iterate - de/serialization no longer supported, throw

v1.12.1

• CLJ-2899 - Revert change in semantics of qualified symbol in invocation position if field and method of same name
• CLJ-2898 - Objects that are both IFn and FunctionalInterface unnecessarily get converted to FI
• CLJ-2888 - gen-class - did not support new array class symbol syntax
• CLJ-2886 - add-libs - send only procurer keys to tool invocation
• CLJ-2906 - Add missing :added metadata to 1.12 functions

v1.12.0

1 Compatibility

1.1 Java 8 - Compatiblity EOL notice

Clojure 1.12 produces Java 8 bytecode (same as Clojure 1.10 and 1.11), but this is expected to be the last release using a Java 8 baseline. Future releases will move the bytecode and minimum Java compatibility to a newer Java LTS release.

1.2 Java 21 - Virtual thread pinning from user code under synchronized

Clojure users want to use virtual threads on JDK 21. Prior to 1.12, Clojure lazy-seqs and delays, in order to enforce run-once behavior, ran user code under synchronized blocks, which as of JDK 21 don't yet participate in cooperative blocking. Thus if that code did e.g. blocking I/O it would pin a real thread. JDK 21 may emit warnings for this when using -Djdk.tracePinnedThreads=full.

To avoid this pinning, in 1.12 lazy-seq and delay use locks instead of synchronized blocks.

See: CLJ-2804

1.3 Security

Fix CVE-2024-22871 detailed in GHSA-vr64-r9qj-h27f:

• CLJ-2839 iterate, cycle, repeat - infinite seqs have infinite hashCode()

1.4 Serialization

CLJ-1327 explicitly sets the Java serialization identifier for the classes in Clojure that implement Java serialization. In Clojure 1.11.0 this changed for two classes unnecessarily and we reverted those changes in Clojure 1.11.1 - this completes that work for the rest of the classes.

Clojure data types have implemented the Java serialization interfaces since Clojure 1.0. Java serialization is designed to save graphs of Java instances into a byte stream. Every class has an identifier (the serialVersionUID) that is automatically generated based on the class name, it's type hierarchy, and the serialized fields. At deserialization time, deserialization can only occur when the available class has an identifier that matches the class id recorded in the serialized bytes.

Clojure has never provided a guarantee of serialization consistency across Clojure versions, but we do not wish to break compatibility any more than necessary and these changes will give us more control over that in the future.

See: CLJ-1327

1.5 Dependencies

Updated dependencies:

• spec.alpha dependency to 0.5.238 - changes
• core.specs.alpha dependency to 0.4.74 - changes

See: CLJ-2852

2 Features

2.1 Add libraries for interactive use

There are many development-time cases where it would be useful to add a library interactively without restarting the JVM - speculative evaluation, adding a known dependency to your project, or adding a library to accomplish a specific task.

Clojure now provides new functions to add libraries interactively, without restarting the JVM or losing the state of your work:

• add-lib takes a lib that is not available on the classpath, and makes it available by downloading (if necessary) and adding to the classloader. Libs already on the classpath are not updated. If the coordinate is not provided, the newest Maven or git (if the library has an inferred git repo name) version or tag are used.
• add-libs is like add-lib, but resolves a set of new libraries and versions together.
• sync-deps calls add-libs with any libs present in deps.edn, but not yet present on the classpath.

These new functions are intended only for development-time interactive use at the repl - using a deps.edn is still the proper way to build and maintain production code. To this end, these functions all check that *repl* is bound to true (that flag is bound automatically by clojure.main/repl). In a clojure.main REPL, these new functions are automatically referred in the user namespace. In other repls, you may need to (require '[clojure.repl.deps :refer :all]) before use.

Library resolution and download are provided by tools.deps. However, you do not want to add tools.deps and its many dependencies to your project classpath during development, and thus we have also added a new api for invoking functions out of process via the Clojure CLI.

See: CLJ-2761, CLJ-2757, CLJ-2788, CLJ-2767, CLJ-2769, CLJ-2770

2.2 Invoke tool functions out of process

There are many useful tools you can use at development time, but which are not part of your project's actual dependencies. The Clojure CLI provides explicit support for tools with their own classpath, but there was not previously a way to invoke these interactively.

Clojure now includes clojure.tools.deps.interop/invoke-tool to invoke a tool function out of process. The classpath for the tool is defined in deps.edn and you do not need to add the tool's dependencies to your project classpath.

add-lib functionality is built using invoke-tool but you can also use it to build or invoke your own tools for interactive use. Find more about the function execution protocol on the CLI reference.

See: CLJ-2760, CLJ-2819

2.3 Start and control external processes

For a long time, we've had the clojure.java.shell namespace, but over time Java has provided new APIs for process info, process control, and I/O redirection. This release adds a new namespace clojure.java.process that takes advantage of these APIs and is easier to use. See:

• start - full control over streams with access to the underlying Java objects for advanced usage
• exec - covers the common case of executing an external process and returning its stdout on completion

See: CLJ-2759, CLJ-2777, CLJ-2828, CLJ-2773, CLJ-2776, CLJ-2774, CLJ-2778, CLJ-2779, CLJ-2865

2.4 Method values

Clojure programmers often want to use Java methods in higher-order functions (e.g. passing a Java method to map). Until now, programmers have had to manually wrap methods in functions. This is verbose, and might require manual hinting for overload disambiguation, or incur incidental reflection or boxing.

Programmers can now use qualified methods as ordinary functions in value contexts - the compiler will automatically generate the wrapping function. The compiler will generate a reflective call when a qualified method does not resolve due to overloading. Developers can supply :param-tags metadata on qualified methods to specify the signature of a single desired method, 'resolving' it.

See: CLJ-2793, CLJ-2844, CLJ-2835

2.5 Qualified methods - Class/method, Class/.method, and Class/new

Java members inherently exist in a class. For method values we need a way to explicitly specify the class of an instance method because there is no possibility for inference.

Qualified methods have value semantics when used in non-invocation positions:

• Classname/method - value is a Clojure function that invokes a static method
• Classname/.method - value is a Clojure function that invokes an instance method
• Classname/new - value is a Clojure function that invokes a constructor

Note: developers must use Classname/method and Classname/.method syntax to differentiate between static and instance methods.

Qualified method invocations with param-tags use only the tags to resolve the method. Without param-tags they behave like the equivalent dot syntax, except the qualifying class takes precedence over hints of the target object, and over its runtime type when invoked via reflection.

Note: Static fields are values and should be referenced without parens unless they are intended as function calls, e.g (System/out) should be System/out. Future Clojure releases will treat the field's value as something invokable and invoke it.

See: CLJ-2844, CLJ-2848, CLJ-2847, CLJ-2853, CLJ-2867

2.6 :param-tags metadata

When used as values, qualified methods supply only the class and method name, and thus cannot resolve overloaded methods.

Developers can supply :param-tags metadata on qualified methods to specify the signature of a single desired method, 'resolving' it. The :param-tags metadata is a vector of zero or more tags: [tag ...]. A tag is any existing valid :tag metadata value. Each tag corresponds to a parameter in the desired signature (arity should match the number of tags). Parameters with non-overloaded types can use the placeholder _ in lieu of the tag. When you supply :param-tags metadata on a qualified method, the metadata must allow the compiler to resolve it to a single method at compile time.

A new metadata reader syntax ^[tag ...] attaches :param-tags metadata to member symbols, just as ^tag attaches :tag metadata to a symbol.

See: CLJ-2805

2.7 Array class syntax

Clojure supports symbols naming classes both as a value (for class object) and as a type hint, but has not provided syntax for array classes other than strings.

Developers can now refer to an array class using a symbol of the form ComponentClass/#dimensions, eg String/2 refers to the class of a 2 dimensional array of Strings. Component classes can be fully-qualified classes, imported classes, or primitives. Array class syntax can be used as both type hints and values.

Examples: String/1, java.lang.String/1, long/2.

See: CLJ-2807

2.8 Functional interfaces

Java programs define "functions" with Java functional interfaces (marked with the @​FunctionalInterface annotation), which have a single method.

Clojure developers can now invoke Java methods taking functional interfaces by passing functions with matching arity. The Clojure compiler implicitly converts Clojure functions to the required functional interface by constructing a lambda adapter. You can explicitly coerce a Clojure function to a functional interface by hinting the binding name in a let binding, e.g. to avoid repeated adapter construction in a loop, e.g. (let [^java.util.function.Predicate p even?] ...).

See: CLJ-2799, CLJ-2858, CLJ-2856, CLJ-2863, CLJ-2864

2.9 Java Supplier interop

Calling methods that take a Supplier (a method that supplies a value) had required writing an adapter with reify. Clojure has a "value supplier" interface with semantic support already - IDeref. All IDeref impls (delay, future, atom, etc) now implement the Supplier interface directly.

See: CLJ-2792, CLJ-2841

2.10 Streams with seq, into, reduce, and transduce support

Java APIs increasingly return Streams and are hard to consume because they do not implement interfaces that Clojure already supports, and hard to interop with because Clojure doesn't directly implement Java functional interfaces.

In addition to functional interface support, Clojure now provides these functions to interoperate with streams in an idiomatic manner, all functions behave analogously to their Clojure counterparts:

• (stream-seq! stream) => seq
• (stream-reduce! f [init-val] stream) => val
• (stream-transduce! xf f [init-val] stream) => val
• (stream-into! to-coll [xf] stream) => to-coll

All of these operations are terminal stream operations (they consume the stream).

See: CLJ-2775

2.11 PersistentVector implements Spliterable

Java collections implement streams via "spliterators", iterators that can be split for faster parallel traversal. PersistentVector now provides a custom spliterator that supports parallelism, with greatly improved performance.

See: CLJ-2791

2.12 Efficient drop and partition for persistent or algorithmic collections

Partitioning of a collection uses a series of takes (to build a partition) and drops (to skip past that partition). CLJ-2713 adds a new internal interface (IDrop) indicating that a collection can drop more efficiently than sequential traversal, and implements that for persistent collections and algorithmic collections like range and repeat. These optimizations are used in drop, nthrest, and nthnext.

Additionally, there are new functions partitionv, partitionv-all, and splitv-at that are more efficient than their existing counterparts and produce vector partitions instead of realized seq partitions.

See: CLJ-2713, CLJ-2742, CLJ-2740, CLJ-2715, CLJ-2718, CLJ-2772, CLJ-2741

2.13 Var interning policy

Interning a var in a namespace (vs aliasing) must create a stable reference that is never displaced, so that all references to an interned var get the same object. There were some cases where interned vars could get displaced and those have been tightened up in 1.12.0-alpha1. If you encounter this situation, you'll see a warning like "REJECTED: attempt to replace interned var #'some-ns/foo with #'other-ns/foo in some-ns, you must ns-unmap first".

This addresses the root cause of an issue encountered with Clojure 1.11.0, which added new functions to clojure.core (particularly abs). Compiled code from an earlier version of Clojure with var names that matched the newly added functions in clojure.core would be unbound when loaded in a 1.11.0 runtime. In addition to CLJ-2711, we rolled back a previous fix in this area (CLJ-1604).

See: CLJ-2711

3 Fixes and enhancements

3.1 Reader and Compiler

• CLJ-2726 #uuid data reader - Fix exception on invalid input so it flows through reader
• CLJ-2813 anonymous function arg reader - no longer accepts invalid arg symbols
• CLJ-2843 Reflective calls to Java methods that take primitive long or double now work when passed a narrower boxed number at runtime (Integer, Short, Byte, Float). Previously, these methods were not matched during reflection and an error was thrown.
• CLJ-2145 - Fix clearing of closed overs in ^:once fns
• CLJ-2317 - recur to head of :once fn cancels once

3.2 Core

• CLJ-2739 ArityException - Fix message when function incorrectly called with >20 args
• CLJ-2709 range - Use optimized range for int args
• CLJ-2721 range - Fix invalid arg order when adding meta to non-optimized range
• CLJ-2683 with-open - Fix to not qualify .close method on expansion
• CLJ-2724 clojure.java.io/do-copy - Fix incorrect type hint
• CLJ-2640 ex-info - now handles nil data map
• CLJ-2717 nthrest now returns rest output on n=0 or past end of seq
• CLJ-1872 empty? - adds support for counted? collections
• CLJ-2694 Fix ratio invariants violated when using Long/MIN_VALUE
• CLJ-2568 clojure.walk/walk - preserve metadata on lists and seqs
• CLJ-2686 clojure.core.server/parse-props - Fix exception if system properties concurrently modified during initialization
• CLJ-2645 PrintWriter-on should support auto-flush, and prepl should use it for the err stream
• CLJ-2698 defprotocol - ignore unused primitive return type hints
• CLJ-2783 replace calls to deprecated URL constructor

3.3 Docstrings

• CLJ-2225 assert and \*assert* - improve docstrings to add context
• CLJ-2290 into - add 0- and 1-arity to docstring
• CLJ-2552 reify - improve docstring and fix example
• CLJ-1385 transient - include usage model from reference docs

v1.11.4

• CLJ-2145 - Fix clearing of closed overs in ^:once fns
• CLJ-2317 - recur to head of :once fn cancels once

v1.11.3

• CLJ-2843 - Reflective calls to Java methods that take primitive long or double now work when passed a narrower boxed number at runtime (Integer, Short, Byte, Float). Previously, these methods were not matched during reflection and an error was thrown.

v1.11.2

Fixes CVE-2024-22871 detailed in GHSA-vr64-r9qj-h27f:

• CLJ-2839 - iterate, cycle, repeat - infinite seqs have infinite hashCode()

v1.11.1

• CLJ-2701
  Pin serialVersionUID for Keyword and ArraySeq back to 1.10.3 values to retain binary serialization

v1.11.0

1 Compatibility

1.1 Security

Because XML external entity (XXE) attacks can be used to disclose local files using file schemes or relative paths in the system identifier, clojure.xml/parse now disables external entity processing by default.

See: https://owasp.org/www-community/vulnerabilities/XML_External_Entity_(XXE)_Processing

This change disables the following SAX parser features:

• http://apache.org/xml/features/nonvalidating/load-external-dtd
• http://xml.org/sax/features/external-general-entities
• http://xml.org/sax/features/external-parameter-entities

If you rely on these features, modify your calls to clojure.xml/parse to explicitly
supply startparse-sax function as the final argument:
(clojure.xml/parse the-string clojure.xml/startparse-sax)
This modification also works on prior Clojure versions.

• CLJ-2611 clojure.xml now disables XXE processing by default

1.2 Dependencies

Updated dependencies:

• spec.alpha dependency to 0.3.218 - changes
• core.specs.alpha dependency to 0.2.62 - changes

2 Features

2.1 Keyword argument functions take a trailing map

Keyword arguments are optional trailing variadic arguments of the form akey aval bkey bval...​.
In Clojure 1.11, functions taking keyword arguments can now be passed a map instead of or in addition
to and following the key/value pairs. When a lone map is passed, it is used for destructuring, else
a trailing map is added to the key/value pair map by conj.

Also see: https://clojure.org/news/2021/03/18/apis-serving-people-and-programs

• CLJ-2603 Clojure keyword argument functions now also accept a map

2.2 :as-alias in require

Spec (and other libs) rely on qualified keywords as spec names.
Namespace aliasing in ns makes long names shorter but required namespaces to be loadable.
This change adds :as-alias to require, which is like :as but does not require the namespace to load.

• CLJ-2123 Add :as-alias option to require like :as but not load
• CLJ-2665 Fix require with :as and :as-alias to load

3 New functions and namespaces

3.1 clojure.math and numeric helper functions

Added a new clojure.math namespace which provides wrappers for the functions available in java.lang.Math.
These functions are narrowed to only long and double overloads and provide primitive support without reflection.

In addition, the following functions were added to clojure.core:

• abs - absolute value in optimized form for all Clojure numeric types (long, double, ratio, bigint, bigdecimal)

• NaN? - predicate for doubles to check whether "not a number"

• infinite? - predicate for doubles to check whether positive or negative infinity

• CLJ-2668 Add NaN? and infinite? predicates

• CLJ-2664 Add clojure.java.math namespace, wrappers for java.lang.Math

• CLJ-2673 Add abs, and update min and max to use Math impls when possible

• CLJ-2677 clojure.math - fix method reflection in bodies and inlines, fix docstrings, renamed

• CLJ-2689 Fix clojure.math tests to be more tolerant of floating point comparisons

3.2 Parser functions

Added the following parsing functions to clojure.core:

• parse-double - parses floating point number, including scientific notation
• parse-long - parses integer in long range
• parse-boolean - parses "true" or "false" to the canonical boolean values
• parse-uuid - parses a UUID string to java.util.UUID

All of these functions expect a string argument and return either the parsed value or nil if the value
is in invalid format.

• CLJ-2667 Add functions to parse a single long/double/uuid/boolean from a string

3.2 random-uuid

Added random-uuid, a function to construct a random java.util.UUID.

• CLJ-1925 Add random-uuid

3.3 update-keys and update-vals

Added:

• update-keys - applies a function to every key in a map, m f => {(f k) v ...}

• update-vals - applies a function to every value in a map, m f => {k (f v) ...}

• CLJ-1959 Add implementation of update-keys

• CLJ-2651 Add implementation of update-vals

3.4 iteration

Added iteration, to repeatedly apply a (possibly impure) step function with continuation state.
This can be used e.g. to consume APIs that return paginated or batched data.

• CLJ-2555 Add iteration generator function
• CLJ-2690 Improve iteration docstring and arg names
• CLJ-2685 Fix iteration generative test failure

4 Fixes

4.1 Compiler

• CLJ-2680 Fix type hinting a primitive local with matching type hint to not error
• CLJ-1180 Fix resolution of class type hints in defprotocol
• CLJ-1973 Make order of emitted protocol methods in generated classes reproducible

4.2 Core

• CLJ-1879 IKVReduce - make IPersistentMap case faster and extend to Object, detaching it from any fully enumerable set of types
• CLJ-2065 IKVReduce - add direct support for SubVector
• CLJ-2663 Fix vector = not terminating when called with infinite sequence
• CLJ-2679 Fix hash collisions in case expressions on symbols
• CLJ-2600 Don't block realized? of delay on pending result
• CLJ-2649 Fix order of checks in some-fn and every-pred for 3 predicate case to match other unrollings
• CLJ-2234 Fix multimethod preferences to correctly use local hierarchy when it exists
• CLJ-2556 Fix into completion so halt-when works

4.3 Performance

• CLJ-1808 map-invert should use reduce-kv and transient
• CLJ-2621 Fix unnecessary boxing of unused return in statement context for instance method expr
• CLJ-2670 Use Math.exact... methods for checked long math ops for performance
• CLJ-2636 Get rid of reflection on java.util.Properties when defining *clojure-version*
• CLJ-1509 AOT compile clojure.instant, clojure.uuid, clojure.core.reducers in build

4.4 Error messages

• CLJ-2529 Fix incorrect reporting of runtime errors as compiler errors in calls through Compiler.load()
• CLJ-2350 Improve keyword arity exception message

4.5 Docstrings

• CLJ-2249 Clarify get docstring regarding sets, strings, arrays, ILookup
• CLJ-2488 Add definition to reify docstring
• CLJ-1360 Update clojure.string/split docstring regarding trailing empty parts
• CLJ-2444 Fix typo in test-vars docstring
• CLJ-2666 Make Clojure Java API javadoc text match the example

4.6 Other enhancements

• CLJ-2493 clojure.java.browse - Fix browse-url hanging on call to xdg-open
• CLJ-1908 clojure.test - Add run-test and run-test-var to run single test with fixtures and report
• CLJ-1379 clojure.test - Fix quoting of :actual form in :pass maps
• CLJ-2620 clojure.server - Fix asymmetric handling of :exception :vals in prepl
• CLJ-2387 clojure.server - Fix off-by-one in socket server port validation

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.