## 1 Deprecated and Removed Features
### 1.1 Clojure 1.5 reducers library requires Java 6 or later
The new reducers library (see below) requires Java 6 plus a ForkJoin
library, or Java 7 or later. Clojure 1.5 can still be compiled and
run with Java 5. The only limitations with Java 5 are that the new
reducers library will not work, and building Clojure requires skipping
the test suite (e.g. by using the command "ant jar").
## 2 New and Improved Features
### 2.1 Reducers
Reducers provide a set of high performance functions for working with collections. The actual fold/reduce algorithms are specified via the collection being reduced. This allows each collection to define the most efficient way to reduce its contents.
The implementation details of reducers are available at the [Clojure blog](http://clojure.com/blog/2012/05/08/reducers-a-library-and-model-for-collection-processing.html) and therefore won't be repeated in these change notes. However, as a summary:
* There is a new namespace: clojure.core.reducers
* It contains new versions of map, filter etc based upon transforming reducing functions - reducers
* It contains a new function, fold, which is a parallel reduce+combine
fold uses fork/join when working with (the existing!) Clojure vectors and maps
* Your new parallel code has exactly the same shape as your existing seq-based code
* The reducers are composable
* Reducer implementations are primarily functional - no iterators
* The model uses regular data structures, not 'parallel collections' or other OO malarkey
* It's fast, and can become faster still
* This is work-in-progress
Examples:
user=> (require '[clojure.core.reducers :as r])
user=> (reduce + (r/filter even? (r/map inc [1 1 1 2])))
;=> 6
;;red is a reducer awaiting a collection
user=> (def red (comp (r/filter even?) (r/map inc)))
user=> (reduce + (red [1 1 1 2]))
;=> 6
user=> (into #{} (r/filter even? (r/map inc [1 1 1 2])))
;=> #{2}
### 2.2 Reader Literals improved
* [CLJ-1034](http://dev.clojure.org/jira/browse/CLJ-1034)
"Conflicting data-reader mapping" should no longer be thrown where there really isn't a conflict. Until this patch, having data_readers.clj on the classpath twice would cause the above exception.
* [CLJ-927](http://dev.clojure.org/jira/browse/CLJ-927)
Added `*default-data-reader-fn*` to clojure.core. When no data reader is found for a tag and `*default-data-reader-fn*`is non-nil, it will be called with two arguments, the tag and the value. If `*default-data-reader-fn*` is nil (the default), an exception will be thrown for the unknown tag.
### 2.3 clojure.core/set-agent-send-executor!, set-agent-send-off-executor!, and send-via
Added two new functions:
* clojure.core/set-agent-send-executor!
Allows the user to set the `java.util.concurrent.Executor` used when calling `clojure.core/send`. Defaults to a fixed thread pool of size: (numCores + 2)
* clojure.core/set-agent-send-off-executor!
Allows the user to set the `java.util.concurrent.Executor` used when calling `clojure.core/send-off`. Defaults to a cached thread pool.
* clojure.core/send-via
Like `send`, and `send-off`, except the first argument to this function is an executor to use when sending.
### 2.4 New threading macros
* clojure.core/cond-> [expr & clauses]
Takes an expression and a set of test/form pairs. Threads the expression (via ->) through each form for which the corresponding test expression (not threaded) is true.
Example:
user=> (cond-> 1
true inc
false (* 42)
(= 2 2) (* 3))
6
* clojure.core/cond->> [expr & clauses]
Takes an expression and a set of test/form pairs. Threads expr (via ->>)
through each form for which the corresponding test expression (not threaded) is true.
Example:
user=> (def d [0 1 2 3])
#'user/d
user=> (cond->> d
true (map inc)
(seq? d) (map dec)
(= (count d) 4) (reduce +)) ;; no threading in the test expr
;; so d must be passed in explicitly
10
* clojure.core/as-> [expr name & forms]
Binds name to expr, evaluates the first form in the lexical context of that binding, then binds name to that result, repeating for each successive form
Note: this form does not actually perform any threading. Instead it allows the user to assign a name and lexical context to a value created by a parent threading form.
Example:
user=> (-> 84
(/ 4)
(as-> twenty-one ;; uses the value from ->
(* 2 twenty-one))) ;; no threading here
42
* clojure.core/some-> [expr & forms]
When expr is not nil, threads it into the first form (via ->),
and when that result is not nil, through the next etc.
Example:
user=> (defn die [x] (assert false))
#'user/die
user=> (-> 1 inc range next next next die)
AssertionError Assert failed: false user/die (NO_SOURCE_FILE:65)
user=> (some-> 1 inc range next next next die)
nil
* clojure.core/some->> [expr & forms]
When expr is not nil, threads it into the first form (via ->>),
and when that result is not nil, through the next etc.
Same as some-> except the value is threaded as the last argument in each form.
### 2.5 Column metadata captured by reader
* [CLJ-960](http://dev.clojure.org/jira/browse/CLJ-960)
Data read by the clojure reader is now tagged with :column in addition to :line.
### 2.6 gen-class improvements
* [CLJ-745](http://dev.clojure.org/jira/browse/CLJ-745)
It is now possible to expose protected final methods via `:exposes-methods` in `gen-class`. This allows Clojure classes created via gen-class to access protected methods of its parent class.
Example:
(gen-class :name clojure.test_clojure.genclass.examples.ProtectedFinalTester
:extends java.lang.ClassLoader
:main false
:prefix "pf-"
:exposes-methods {findSystemClass superFindSystemClass})
* [CLJ-948](http://dev.clojure.org/jira/browse/CLJ-948)
It is now possible to annotate constructors via `gen-class`.
Example:
(gen-class :name foo.Bar
:extends clojure.lang.Box
:constructors {^{Deprecated true} [Object] [Object]}
:init init
:prefix "foo")
### 2.7 Support added for marker protocols
* [CLJ-966](http://dev.clojure.org/jira/browse/CLJ-966)
`defprotocol` no longer requires that at least one method be given in the definition of the protocol. This allows for marker protocols, whose sole reason of existence is to allow `satisfies?` to be true for a given type.
Example:
user=> (defprotocol P (hi [_]))
P
user=> (defprotocol M) ; marker protocol
M
user=> (deftype T [a] M P (hi [_] "hi there"))
user.T
user=> (satisfies? P (T. 1))
true
user=> (satisfies? M (T. 1))
true
user=> (hi (T. 1))
"hi there"
user=> (defprotocol M2 "marker for 2") ; marker protocol again
M2
user=> (extend-type T M2)
nil
user=> (satisfies? M2 (T. 1))
true
### 2.8 clojure.pprint/print-table output compatible with Emacs Org mode
For the convenience of those that use Emacs Org mode,
`clojure.pprint/print-table` now prints tables in the form used by
that mode. Emacs Org mode has features to make it easy to edit such
tables, and even to do spreadsheet-like calculations on their
contents. See the [Org mode documentation on
tables](http://orgmode.org/manual/Tables.html) for details.
user=> (clojure.pprint/print-table [:name :initial-impression]
[{:name "Rich" :initial-impression "rock star"}
{:name "Andy" :initial-impression "engineer"}])
| :name | :initial-impression |
|-------+---------------------|
| Rich | rock star |
| Andy | engineer |
### 2.9 clojure.string/replace and replace-first handle special characters more predictably
`clojure.string/replace` and `clojure.string/replace-first` are now
consistent in the way that they handle the replacement strings: all
characters in the replacement strings are treated literally, including
backslash and dollar sign characters.
user=> (require '[clojure.string :as s])
user=> (s/replace-first "munge.this" "." "$")
;=> "munge$this"
user=> (s/replace "/my/home/dir" #"/" (fn [s] "\\"))
;=> "\\my\\home\\dir"
There is one exception, which is described in the doc strings. If you
call these functions with a regex to search for and a string as the
replacement, then dollar sign and backslash characters in the
replacement string are treated specially. Occurrences of `$1` in the
replacement string are replaced with the string that matched the first
parenthesized subexpression of the regex, occurrences of `$2` are
replaced with the match of the second parenthesized subexpression,
etc.
user=> (s/replace "x12, b4" #"([a-z]+)([0-9]+)" "$1 "x (s/replace "x12, b4" #"([a-z]+)([0-9]+)"
(s/re-quote-replacement "$1 "$1