Clojure JIRA

[CLJ-1168] Setting clojure.read.eval to unknown on JVM cmd line causes --eval option to fail

Fri, 22 Feb 2013 14:12:22 -0600

First discovered by Tim McCormack with Clojure 1.5.0-beta13 and -RC15:

$ java -Dclojure.read.eval=unknown -jar ~/.m2/repository/org/clojure/clojure/1.5.0-RC16/clojure-1.5.0-RC16.jar -e "(+ 1 2)"
Exception in thread "main" java.lang.RuntimeException: Reading disallowed - read-eval bound to :unknown

This would prevent a Leiningen user from putting the following line in their project.clj file in order to look for read or read-string calls that don't explicitly bind read-eval to true or false:

:jvm-opts ["-Dclojure.read.eval=unknown"]

[CLJ-1163] Updates to changes.md for Clojure 1.5.0-RC15

Wed, 13 Feb 2013 21:26:19 -0600

Attached patch contains additional changes that have been made since late Oct 2012 up through Clojure 1.5.0-RC15. Also a few minor formatting tweaks to recently added section on edn reader.

[CLJ-1158] generative tests for read and edn/read

Sat, 9 Feb 2013 14:46:21 -0600

This patch gets some generative read and edn/read roundtripping tests into the build, and the generators should serve as a basis for further extension. The patch is broken into three commits:

adopt the latest test.generative and data.generators, which have been enhanced to include generators more types (e.g. uuid, date, ratio)
tests
increase the duration of generative tests in the build

At the time I am posting this, test.generative 0.4.0 is not in Maven Central, so to build Clojure with this patch you will need to either wait on Central, or grab the latest test.generative bits, back up to the commit tagged 0.4.0, and mvn clean install test.generative.

[CLJ-1150] Make some PersistentVector, SubVector internals public

Fri, 1 Mar 2013 09:49:20 -0600

This should help with RRBT-PV interop.

[CLJ-1140] {:as x} destructuring with an empty list raises exception

Fri, 1 Mar 2013 09:49:21 -0600

user=> (clojure-version)
"1.4.0"
user=> (let [{:as x} '()] x)
{}

...

user=> (clojure-version)
"1.5.0-RC1"
user=> (let [{:as x} '()] x)
IllegalArgumentException No value supplied for key: null  clojure.lang.PersistentHashMap.create (PersistentHashMap.java:77)

The bug was introduced by a change[1] to support duplicate keys in map
destructuring. Using PersistentHashMap/create here introduces the above
bug, since it does not properly handle empty lists.

[1]: https://github.com/clojure/clojure/commit/93c795fe10ee5c92a36b6ec6373b3c80a31135c4

[CLJ-1135] Add previous changelog items back to changes.md

Sat, 2 Feb 2013 16:32:09 -0600

Add previous changelog items back to changes.md

[CLJ-1116] More REPL-friendly 'ns macro

Fri, 1 Mar 2013 09:49:21 -0600

The 'ns macro is not as dynamic as it could be.
For instance, the following line typed in a repl (ns a)(ns b (:require a)) currently (1.4, 1.3, etc.) fails with an exception because the (:require a) call tries to reach the filesystem for file a.clj or a__init.class.

The attached patch ( dynamic-ns-patch2.diff ) allows a successful call to (ns a) behave the same as a successful call to (require 'a), adding namespace a to the list of loaded-libs.

Discussion on googlegroup's mailing list: http://groups.google.com/group/clojure-dev/browse_thread/thread/fb231e6fab4a5ad

[CLJ-1114] reify ignores :pre and :post

Sat, 15 Dec 2012 07:30:40 -0600

reify ignores :pre and :post assertions

user=> ((reify clojure.lang.IFn (invoke [this] {:pre [false]} (println "hello"))))
hello
nil
user=> ((fn [this] {:pre [false]} (println "hello")) 0)
AssertionError Assert failed: false user/eval39/fn--40 (NO_SOURCE_FILE:13)

Expected exception to be thrown

[CLJ-1111] Loops returning primtives are boxed even in return position

Sat, 22 Dec 2012 09:53:50 -0600

Reported here: https://groups.google.com/d/topic/clojure/atoFzbyuyos/discussion

(defn first-bit?
  {:inline (fn [n] `(== 1 (clojure.lang.Numbers/and ~n, 1)) )}
  [^long n]
  (== 1 (clojure.lang.Numbers/and n, 1)))

(defn exp-int
  ^double [^double x, ^long c]
  (loop [result 1.0, factor x, c c]
    (if (> c 0)
        (recur
         (if (first-bit? c)
           (* result factor)
           result),
         (* factor factor),
         (bit-shift-right c 1))
      result)))

Last lines of the Java bytecode of `exp-int`:

59 dload 5;               /* result */
61 invokestatic 40;       /* java.lang.Double java.lang.Double.valueOf(double c) */
64 checkcast 85;          /* java.lang.Number */
67 invokevirtual 89;      /* double doubleValue() */
70 dreturn;

The compiler doesn't currently infer the primitive type as soon as there is a recur:

(use '[clojure.contrib.repl-utils :only [expression-info]])
(expression-info '(loop [a 1] a))
;=> {:class long, :primitive? true}
(expression-info '(loop [a 1] (if true a (recur a)))
;=> nil

Patch attached.

[CLJ-1110] let-> needs improvement

Tue, 11 Dec 2012 01:03:39 -0600

The function clojure.core/let-> is suboptimal in a few regards:
1. It's name lends you to believe it is "let-like", but it is not - it does not take a binding form, and its arguments are 'backwards'
2. It's docstring doesn't make clear that it is intended for use solely in a threading-macro expression
3. It arbitrarily does not support destructuring, where it easily could.

Possible solutions:

rename it (e.g. to "bind->") to make clear it is not let-like
allow destructuring of the 'name' parameter

Google groups discussion: https://groups.google.com/d/topic/clojure/67JQ7xSUOM4/discussion

[CLJ-1109] Oracle Java 5 fails to run tests when building Clojure

Sat, 15 Dec 2012 07:33:44 -0600

This is due to the way that reducers.clj currently handles the ForkJoin library.

[CLJ-1106] Broken equality for sets

Fri, 1 Mar 2013 09:49:21 -0600

Equality for sets is not consistent with other persistent collections when the hashCode differs:

(= {(Integer. -1) :foo} {(Long. -1) :foo})
=> true

(= [(Integer. -1)] [(Long. -1)])
=> true

(= #{(Integer. -1)} #{(Long. -1)})
=> false

Attached is what I believe to be a basic fix. It removes a hashCode check from APersistentSet.equals. A similar check was removed from APersistentMap in the following commit:

https://github.com/clojure/clojure/commit/b5f5ba2e15dc2f20e14e05141f7de7c6a3d91179

With this patch, set equality works as expected and all tests pass.

My understanding of the implications of this change are limited, so someone more knowledgeable would need to chime in about its correctness.

[CLJ-1098] Extend CollFold and IKVReduce to nil

Fri, 1 Mar 2013 09:49:21 -0600

Currently, reduce-kv and fold throw when used on nil, because their respective protocols don't extend to nil. This seems strange, since Clojure tends to handle nils gracefully where possible, especially in places where collections are expected.

See thread https://groups.google.com/d/topic/clojure/tGI8sIKQoh0/discussion

[CLJ-1092] New function re-quote-replacement has incorrect :added metadata

Sat, 22 Dec 2012 09:53:50 -0600

I created the patch for ~~CLJ-870~~ that added the function re-quote-replacement before Clojure 1.4 was released, and I was apparently hoping it would get into that release. It is in now, but incorrectly states that fn re-quote-replacement was added in 1.4.

[CLJ-1091] update changes.md to include 1.5 changes

Tue, 11 Dec 2012 13:09:08 -0600

update changes.md to include 1.5 changes

[CLJ-1085] clojure.main/repl unconditionally refers REPL utilities into ns

Sat, 20 Oct 2012 09:53:42 -0500

A number of vars from clojure.repl, clojure.java.javadoc, and clojure.pprint are unconditionally referred into *ns* by clojure.main/repl. This is fine when it is being used e.g. as the primary driver of a terminal-bound Clojure REPL, but other usages can end up bringing those utility vars into namespaces other than 'user. This can cause problems if clojure.main/repl is used to drive a REPL within namespaces that already have referred or interned vars with the same names as those utility vars, e.g.:

$ java -jar ~/.m2/repository/org/clojure/clojure/1.5.0-alpha6/clojure-1.5.0-alpha6.jar
Clojure 1.5.0-alpha6
user=> (ns foo)
nil
foo=> (defn pp [] "hi!")
#'foo/pp
foo=> (pp)
"hi!"
foo=> (clojure.main/repl)
foo=> (pp)
nil
nil
foo=> (defn pp [] "whoops")
CompilerException java.lang.IllegalStateException: pp already refers to: #'clojure.pprint/pp in namespace: foo, compiling:(NO_SOURCE_PATH:7:1)

Worse, nREPL uses clojure.main/repl (in large part to maximize the consistency of REPL behaviour across different Clojure versions), where each user expression is evaluated through a separate clojure.main/repl invocation. This leads to the same problems as above, but for every nREPL user, session, and expression (reported @ ~~NREPL-31~~).

A simple fix for this is to perform these refers only if *ns* is 'user (which, AFAICT, was the only intended effect of ~~CLJ-310~~, ~~CLJ-454~~, and https://github.com/clojure/clojure/commit/04764db, the changes that added these automatic implicit refers to clojure.main/repl).

[CLJ-1084] (object-array [1]) is ~3x slower than (object-array (rseq [1]))

Sat, 20 Oct 2012 09:53:42 -0500

{{user=> (time (dotimes [_ 10000000] (object-array [1])))
"Elapsed time: 1178.116257 msecs"
nil
user=> (time (dotimes [_ 10000000] (object-array (rseq [1]))))
"Elapsed time: 422.42248 msecs"
nil}}

This appears to be because PersistentVector$ChunkedSeq does not implement Counted, so RT.count is iterating the ChunkedSeq to get its count.

[CLJ-1071] ExceptionInfo does no abstraction

Fri, 21 Sep 2012 14:21:33 -0500

There oughtta be an interface

[CLJ-1070] PersistentQueue's hash function does not match its equality

Sat, 20 Oct 2012 09:53:42 -0500

There are two issues:

1) PersistentQueue's hash function doesn't match its equiv function:

(def iq (conj clojure.lang.PersistentQueue/EMPTY (Integer. -1)))
(def lq (conj clojure.lang.PersistentQueue/EMPTY (Long. -1)))
[(= iq lq) (= (hash iq) (hash lq))]
;=> [true false]

2) PersistentQueue's hash function doesn't match PersistentVector's hash:

(def q (conj clojure.lang.PersistentQueue/EMPTY 1 2 3))
[(= [1 2 3] q) (= (hash [1 2 3]) (hash q))]
;=> [true false]

[CLJ-1066] No dependency on jsr166y

Sat, 20 Oct 2012 09:53:42 -0500

The Clojure 1.5.0-alpha4 jars that have been deployed to maven.org seem to have been compiled against JDK6 which causes
an exception if one tries to use reducers/fold.

— snip —
Setup:

user=> (require '[clojure.core.reducers :as r])
nil
user=> (def v (vec (range 10000)))
#'user/v

;; JDK7 + clojure 1.5.0-alpha4 from maven.org
;; → :dependencies [[org.clojure/clojure "1.5.0-alpha4"]] in project.clj

user=> (r/fold + (r/map inc v))
ClassNotFoundException jsr166y.ForkJoinTask java.net.URLClassLoader$1.run (URLClassLoader.java:366)

;; JDK7 + clojure 1.5.0-alpha4 from maven.org
;; → :dependencies [[org.clojure/clojure "1.5.0-alpha4"]
;; [org.codehaus.jsr166-mirror/jsr166y "1.7.0"]]

user=> (r/fold + (r/map inc v))
50005000

;; JDK7 + clojure 1.5.0-alpha4 locally compiled (mvn install) against OpenJDK7
;; → :dependencies [[org.clojure/clojure "1.5.0-alpha4"]] in project.clj

user=> (r/fold + (r/map inc v))
5000050000
— snip —

It would be wonderful if this issue could be fixed before the release of 1.5.0.

Have a nice day

Wolodja

[CLJ-1065] Allow duplicate set elements and map keys for all set and map constructors

Thu, 4 Oct 2012 10:15:06 -0500

See description here http://dev.clojure.org/display/design/Allow+duplicate+map+keys+and+set+elements

[CLJ-1062] CLJ-940 breaks compilation of namespaces that don't have any public functions

Fri, 1 Mar 2013 09:49:20 -0600

~~CLJ-940~~ that was recently committed to master break compilation of namespaces that don't have any public functions in them
(for example, like https://github.com/michaelklishin/monger/blob/master/src/clojure/monger/json.clj that only extends
a protocol).

This affects several of clojurewerkz.org projects that no longer can compile with 1.5.0-master-SNAPSHOT.

[CLJ-1061] when-first double evaluation

Sat, 20 Oct 2012 09:53:42 -0500

The when-first macro will evaluate the xs expression twice. Admittedly, it does exactly what the doc string says, but that seems undesirable to me. Even without side effects, there's a potential performance issue if xs is some expensive operation.

Patch attached. The main diff is:

- `(when (seq ~xs)
- (let [~x (first ~xs)]
- ~@body))))
+ `(when-let xs# (seq ~xs)
+ (let ~x (first xs#)
+ ~@body))))

[CLJ-1055] "be come" should be "become"

Mon, 17 Sep 2012 07:11:51 -0500

There is a typo in core.clj in the docs for "agent", "ref", and "atom": it should be "become" instead of "be come".

[CLJ-1052] assoc should throw exception if missing val for last key

Sat, 20 Oct 2012 09:53:42 -0500

https://groups.google.com/forum/?fromgroups=#!topic/clojure/k2R4OdPUCzg

Suggested by Ambrose Bonnaire-Sergeant:

I think assoc should throw an error when applied with uneven arguments.

Currently, the "missing" value is just replaced with nil.

(assoc {} :a 1 :b)
;=> {:a 1, :b nil}

[CLJ-1048] add test.generative to Clojure's tests

Fri, 1 Mar 2013 09:49:21 -0600

The 0.1.5 release of test generative includes data generators and specs based on data generation, plus a runner that can run both c.t and c.t.g. tests under the same umbrella.

[CLJ-1041] reduce-kv on sorted maps should stop on seeing a Reduced value

Sat, 18 Aug 2012 07:12:53 -0500

The current implementation is dereferencing Reduced and returning them up the chain; but that means that parent nodes don't know the reduction has completed, so the reduction might continue along other paths down the tree.

This patch touches the same areas of code as ~~CLJ-1040~~ so will have conflicts if both patches are merged separately. However, as noted in my comment on ~~CLJ-1040~~, I don't think the patch there is correct yet, so I've also included a commit (7beb14256) to fix the issue in ~~CLJ-1040~~. Thus, this patch can be merged independently of 1040's patch, solving both issues without a merge conflict.

This patch also includes tests for both issues, which fail before my commits are applied, and pass afterwards.

[CLJ-1038] Docstring for deliver doesn't match behavior

Fri, 1 Mar 2013 12:47:10 -0600

The docstring for deliver doesn't match the actual behavior. It says an exception gets thrown on multiple delivers, but that's no longer the case, as of 1.3 (hat tip to clgv on irc).

user=> (doc deliver)
-------------------------
clojure.core/deliver
([promise val])
  Alpha - subject to change.
  Delivers the supplied value to the promise, releasing any pending
  derefs. A subsequent call to deliver on a promise will throw an exception.
nil

(let [p (promise)] 
  (deliver p "hi") 
  (deliver p "bye") 
  @p)
;=> "hi"

This patch updates the docstring to reflect actual behavior: "will throw an exception." -> "will have no effect."

[CLJ-1034] "Conflicting data-reader mapping" triggered when the same data_readers.clj is on the classpath twice

Sat, 1 Sep 2012 08:37:48 -0500

If you have two data_readers.clj files on the classpath that agree with one another about the mapping of a given literal, Clojure still claims there is a conflict.

[CLJ-1032] seque leaks threads from the send-off pool

Fri, 1 Mar 2013 09:49:21 -0600

Because a new (fill) action is created every time an item is (drain)ed, the LBQ gets loaded up with piles of EOS markers. If the output seq is consumed faster than the input sequence can produce items, then the original agent action does all of the filling in a single action, while the agent's queue continues to back up with (fill) actions. Eventually the entire sequence is consumed, and each queued action does a blocking .put of an EOS marker; once the queue has filled up, one of these actions blocks forever, since nobody will ever .take from the queue again.

The attached patch does two things:

Make sure to put exactly one EOS marker in the stream, by setting the agent's state to nil if and only if a .offer of EOS has been accepted.
Replace all occurrences of .put with .offer (and appropriate checking of the return value). This is necessary because if .put ever blocks, it's possible for the system to remain in that state forever (say, because the client stops consuming the queue), thus leading to the same leaked-thread scenario.

The diff is a little bit inconvenient to read because of indentation changes; https://gist.github.com/b7ecd4395a0d3d473de6 is an ignore-whitespace view of the patch for convenience.

[CLJ-1031] Website documentation for evaluation has misleading information about "load"

Fri, 10 Aug 2012 13:08:50 -0500

In the documentation at http://clojure.org/evaluation the documentation says "(load reader)" and the verbiage below mentions loading from a stream or file. This is misleading since "load" doesn't take a reader, but a resource. It would also be great to have pointers to load-reader and load-string here. (Where is the source for the website generated from? Is it possible to create a patch/pull request for it?)

[CLJ-1019] ns-resolve doc has a typo

Sat, 18 Aug 2012 07:12:52 -0500

The doc string for ns-resolve has a typo: environement should be environment.

[CLJ-1012] partial function should also accept 1 arg (just f)

Sat, 18 Aug 2012 07:12:52 -0500

The partial function should accept just a function. This allows it to be properly used with apply.

E.g. This breaks (but shouldn't) if args are nil: (apply partial f args)

[CLJ-1011] clojure.data/diff should cope with null and false values in maps

Sat, 18 Aug 2012 07:12:52 -0500

Current behaviour of clojure.data/diff:

=> (diff {:a false} {:a true})
(nil {:a true} nil)
=> (diff {:a false} {:a nil})
(nil nil nil)

Proposed behaviour:

=> (diff {:a false} {:a true})
({:a false} {:a true} nil)
=> (diff {:a false} {:a nil})
({:a false} {:a nil} nil)

[CLJ-1009] make print-table org mode compatible

Sat, 18 Aug 2012 07:12:53 -0500

make print-table org mode compatible

[CLJ-1000] Performance drop in PersistentHashMap.valAt(...) in v.1.4 -- Util.hasheq(...) ?

Fri, 1 Mar 2013 09:49:21 -0600

It seems there is a 30-40% performance degradation of PersistentHashMap.valAt(...) in Clojure 1.4.
Possibly due to references to new CPU-hungry implementation of Util.hasheq(...).

I have created a demo project with more details and some profiling information here:
https://github.com/oshyshko/clj-perf

[CLJ-990] Implement clojure.core.reducers/mapcat and some initial reducers tests

Fri, 1 Mar 2013 09:49:21 -0600

The first patch implements a reducers equivalent of clojure.core/mapcat, and the second patch adds a new reducers.clj to the clojure tests that checks that map, mapcat, filter, and reduce are equivalent in clojure.core and clojure.core.reducers.

[CLJ-989] clojure.org/downloads page, nightly builds link out of date

Thu, 10 May 2012 20:52:02 -0500

The clojure.org/downloads page links a page that claims to have up to date builds of Clojure's master branch at build.clojure.org.

Either build.clojure.org needs to be updated, or the link should be removed or changed to reflect the statement.

On a personal note, I'd like to be able to link to alpha/beta versions of clojure 1.5.

[CLJ-988] the locking in MultiFn.java (synchronized methods) can cause lots of contention in multithreaded programs

Fri, 21 Sep 2012 14:21:33 -0500

if you call a single multimethod a lot in multithreaded code you get lots of contention for the lock on the multimethod. this contention slows things down a lot.

this is due to getMethod being synchronized. it would be great if there was some fast non-locking path through the multimethod.

[CLJ-987] pprint doesn't flush the underlying stream

Fri, 1 Mar 2013 09:49:20 -0600

Unlike prn, pprint doesn't flush the underlying stream.

pretty_writer currently overrides .flush with behaviour that pushes its own data, but does not flush the underlying stream.

pprint should behave similarly to prn with respect to flushing the underlying stream.

[CLJ-985] make jsr166 available at build time

Fri, 1 Mar 2013 09:49:20 -0600

but no runtime requirement.

[CLJ-981] clojure.set/rename-keys deletes keys when there's a collision

Fri, 15 Jun 2012 11:09:26 -0500

(set/rename-keys {:a "one" :b "two" :c "three"} {:a :b :b :a}) returns {:b "one" :c "three"}
should be {:a "two" :b "one" :c "three"}

I have created a pull request for a fix, here: https://github.com/clojure/clojure/pull/23

[CLJ-977] (int \a) returns a value, (long \a) throws an exception

Sat, 18 Aug 2012 07:12:53 -0500

As described in the summary, calling (long ...) on a character throws a ClassCastException. I know the semantics surrounding numbers has changed a bit, but I think it would be nice for this to be consistent.

[CLJ-975] inconsistent destructuring behaviour when using nested maps

Fri, 18 May 2012 20:36:45 -0500

The way destructuring happens should not be affected by the fact that I have the same w at two-levels.
user>> (let [{{a :a b :b :as w} :c a1 :a b1 :b :as w} {:a 10 :b 20 :c {:a 30 :b 40}}] {:a a :b b :b1 b1 :a1 a1})
{:a 30, :b 40, :b1 40, :a1 30} <- unexpected behaviour.....

user>> (let [{{a :a b :b :as w} :c a1 :a b1 :b :as w1} {:a 10 :b 20 :c {:a 30 :b 40}}] {:a a :b b :b1 b1 :a1 a1})
{:a 30, :b 40, :b1 20, :a1 10} <- expected behaviour ..

Even having the :as things from both should not affet how others are destructured.. The email thread talking about the same is here

https://groups.google.com/forum/?fromgroups#!topic/clojure/3z3JtXhcDB0

[CLJ-973] doc for data-readers is wrong about the format for data_readers.clj

Sat, 14 Apr 2012 13:52:46 -0500

Sometime recently, the format for data_readers.clj changed to require a read-time literal map instead of pairs of symbols. The doc string for *data-readers* should be updated to reflect the change.

[CLJ-972] Document changes between Clojure 1.3 and 1.4

Sun, 15 Apr 2012 08:13:42 -0500

The changes between Clojure 1.3 and 1.4 need to be documented before release.

[CLJ-966] Add support for marker protocols

Sat, 18 Aug 2012 07:50:41 -0500

The attached patch adds support to marker protocols, for example

(defprotocol Sequential
"marker protocol indicating a sequential type")

[CLJ-965] clojure.org/patches should have link to JIRA workflow wiki page added, and most content removed

Thu, 10 May 2012 20:49:44 -0500

http://groups.google.com/group/clojure-dev/browse_frm/thread/12e90e460aec29cb

Relevant text supporting this suggestion copied below:

[1] http://dev.clojure.org/display/design/JIRA+workflow

Only a few have permission to edit this page:

[2] http://clojure.org/patches

I have carefully reviewed the content of those two side by side, section by section, and it seems to me that they are either identical, or [1] is more up to date.

I am not proposing getting rid of [2], but instead do this:

Keep the first section headed "Submitting patches to Clojure and Clojure Contrib" exactly as it is now.

Immediately under the heading "So You Have an Idea...", put a single link, perhaps with one sentence or phrase, that points at [1]. Delete all other text from there down on [2]. You will lose nothing worth saving, and you will save future confusion as what is now [2] gets more and more stale.

[CLJ-964] test-clojure/rt.clj has undeclared dependency on clojure.set

Sat, 18 Aug 2012 07:12:53 -0500

In test-clojure/rt.clj, the test last-var-wins-for-core evaluates #'clojure.set/subset?. This fails unless clojure.set has been loaded. In the normal run of the test suite, this dependency is satisfied by test-clojure/core-set being loaded first.

[CLJ-963] Support pretty printing namespace declarations under code-dispatch

Sat, 1 Sep 2012 08:37:48 -0500

Currently when you print code with an (ns ) declaration in it, the ns declaration comes out kind of messy. This patch makes that beautiful.

[CLJ-962] Vectors returned by subvec allow access at negative indices

Fri, 18 May 2012 10:03:07 -0500

Google group thread: https://mail.google.com/mail/?shva=1#label/clojure/1365e058eaf0d5fa

Vectors returned by subvec correctly disallow access to elements after their end, but not before their beginning.

Clojure 1.3.0
user=> (def v1 (vec (range 100)))
#'user/v1
user=> (def v2 (subvec v1 50 52))
#'user/v2
user=> (v2 3)
IndexOutOfBoundsException clojure.lang.APersistentVector$SubVector.nth (APersistentVector.java:526)
user=> (v2 -48)
2

[CLJ-961] with-redefs loses a Var's root binding if the Var is thread-bound

Fri, 20 Jul 2012 16:44:41 -0500

When a Var has an in-thread binding and I use with-redefs to temporarily alter its root binding, the value restored to the root binding after with-redefs is finished will not be the original root value, but the thread-local one. The problem is using deref instead of something like clojure.lang.Var's .getRawRoot to backup the original root values in with-derefs-fn.

I have never used with-redefs and it is very unlikely that one would use it while the Vars in question are thread-bound. However, when reading the function's definition in Joy of Clojure and later in core.clj, I did not believe this behaviour was intended.

[CLJ-960] Capture :column metadata (needed for ClojureScript source maps)

Sat, 20 Oct 2012 09:53:42 -0500

I've begun working on implementing SourceMaps for ClojureScript. For an overview of SourceMaps, see: http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/ For discussion of the feature in ClojureScript, see: https://groups.google.com/d/topic/clojure-dev/zgmXO2iM1JQ/discussion

In order to produce accurate source maps, I need column information in addition to line information from the Clojure reader.

I've made the necessary enhancement to LispReader, etc. but have some cleanup and testing left to do. I'd also like a sanity check from the core team before attaching a formal patch. You can find my work in progress here: https://github.com/brandonbloom/clojure/compare/columns

[CLJ-954] TAP Support in clojure.test.tap Needs Updating

Fri, 18 May 2012 20:36:58 -0500

The testing-vars-str function requires one argument, but in the clojure.test.tap namespace it is currently called with zero arguments. This results in a clojure.lang.ArityException when attempting to generate TAP output with with-tap-out.

Here are links to the occurrences of this in the latest commit to clojure.test.tap:

1. https://github.com/clojure/clojure/blob/36642c984cbf52456e45a8af0a96e4b7e7417041/src/clj/clojure/test/tap.clj#L81
2. https://github.com/clojure/clojure/blob/36642c984cbf52456e45a8af0a96e4b7e7417041/src/clj/clojure/test/tap.clj#L92

After fixing this particular issue in my local copy of 1.4.0-SNAPSHOT, there appear to be other problems with this code as well (e.g., not producing correct output for failing tests). Since this code appears to be unmaintained and untested, perhaps it should live outside the main Clojure repo?

[CLJ-953] drop-while doc string wrong, nil instead of logical false

Fri, 30 Mar 2012 09:16:31 -0500

"Returns a lazy sequence of the items in coll starting from the first
-  item for which (pred item) returns nil."
+  item for which (pred item) returns logical false."

[CLJ-952] bigdec does not properly convert a clojure.lang.BigInt

Fri, 18 May 2012 12:32:12 -0500

bigdec handles java.math.BigInteger when converting to java.math.BigDecimal, but it does not handle clojure.lang.BigInt. Instead it treats a clojure.lang.BigInt as a Number, by casting it to long. This causes the following error:

Clojure 1.4.0-beta3
user=> (bigdec (inc (bigint Long/MAX_VALUE)))
IllegalArgumentException Value out of range for long: 9223372036854775808 clojure.lang.RT.longCast (RT.java:1123)

[CLJ-948] It would be very useful to be able to annotate the constructors of classes created with gen-class

Sat, 20 Oct 2012 09:53:42 -0500

gen-class currently provides a way to annotate methods, but not constructors.

when interoperating with java code that uses google juice heavily the ability to annotate constructors is required.

[CLJ-943] When load-lib fails, a namespace is still created

Fri, 15 Jun 2012 11:09:26 -0500

When requiring a namespace that doesn't compile, a namespace is still created. The attached patch removes the namespace on failure if the namespace wasn't already present on entry to load-lib. See the test case in the patch for repro instructions.

This is obviously a subset of having atomic loads. Would a step further in this direction, e.g. using a swapable state object within clojure.lang.Namespace be of interest?

[CLJ-942] Calls to instance methods through the Reflector double unwrap exceptions

Fri, 9 Mar 2012 13:46:03 -0600

When calling an instance method with one or more arguments, if an exception is thrown that has a cause, then that exception is wrapped in an InvocationTargetException. The Reflector tries to unwrap that, but it also unwraps the exception that is thrown by the method being called reflectively.

[CLJ-940] Passing a non-sequence to refer :only results in uninformative exception

Sat, 1 Sep 2012 08:37:48 -0500

Compiling the following code results in a Don't know how to create ISeq from: clojure.lang.Symbol exception

code
(ns clj14.myns
(:use
[clojure.core :only seq]))
code

[CLJ-936] Improve docs about argument destructuring at clojure.org

Fri, 1 Mar 2013 09:49:21 -0600

What:
Make the description of argument destructuring more visible at http://clojure.org/special_forms, namely:

add a heading such as "<h4>Binding Forms (Argument Destructuring)</h4>" to the section describing it
make all occurences of "binding-form" a link to that heading, especially under the let and fn headings
for (fn ..) add a new second paragraph like "Regarding binding forms, also known as argument destructuring, <a href=#thea-new-heading>read more in the binding forms section</a> under the let special form."

Why:
It was always surprisingly difficult for me to google out the explanation of destructuring in Clojure and only today have I discovered that it is described pretty well under the let special form. Thus it should be made more visible to the readers (and preferably also search engines). (Even though Google has returned the page as one of the first matches, I had problems seeing it there - partly due to usually mistyping destructuring e.g. as deconstruction).

Thanks a lot!

PS: I haven't found a better way to report this, such as a commenting capability on the page itself.

[CLJ-934] disj! throws exception when attempting to remove multiple items in one call

Fri, 15 Jun 2012 11:09:26 -0500

disj! fails whenever called with multiple items to remove:

user=> (-> #{5 10 15 20} transient (disj! 10 15) persistent!)
ClassCastException clojure.lang.PersistentHashSet$TransientHashSet cannot be cast to clojure.lang.IPersistentSet clojure.core/disj (core.clj:1419)

It is a simple one line fix to disj! Clojure source code to correct this.

[CLJ-933] Compiler warning on clojure.test-clojure.require-scratch

Fri, 1 Mar 2013 12:47:05 -0600

During Clojure build:

[java] Testing clojure.test-clojure.java-interop
    [java] WARNING: with-bindings already refers to: #'clojure.core/with-bindings in namespace: clojure.test-clojure.require-scratch, being replaced by: #'clojure.main/with-bindings

[CLJ-932] contains? should throw exception on non-keyed collections

Sat, 18 Aug 2012 07:50:41 -0500

The contains? function, given a collection which is not an associative (Map, Set, String, array), returns false instead of throwing an exception.

This is a subject of confusion when people call contains? on sequential collections like lists, and on associative collections which do not implement the Associative interface.

Other predicates, such as even?, throw an exception when passed arguments of an invalid type.

[CLJ-931] Syntactically broken clojure.test/are tests succeed

Fri, 23 Mar 2012 08:40:35 -0500

While clojure.test/are is a very useful macro, it has one major flaw. If the assertion is syntactically incorrect, the test succeeds. Take this testcase:

(deftest broken-test
  (are [a b c] (= a b c)
       1 1))

See the error? The are form takes three values, but I have provided only two. The test simply passes.

Latest patch checks the number of arguments to are and throws an exception if they don't match.

[CLJ-928] instant literal for Date and Timestamp should print in UTC

Fri, 1 Mar 2013 12:46:58 -0600

The default #inst returns a java.util.Date. Date is always in UTC, and doesn't know about time zones, but the implementation of the print method always renders it in the default time zone. For example,

user=> #inst "2012Z"
#inst "2011-12-31T19:00:00.000-05:00"

RFC3339 says:

4.3. Unknown Local Offset Convention

If the time in UTC is known, but the offset to local time is unknown,
this can be represented with an offset of "-00:00". This differs
semantically from an offset of "Z" or "+00:00", which imply that UTC
is the preferred reference point for the specified time.

java.sql.Timestamp should also print in UTC since that class doesn't keep timezone information. The print-method for Timestamp seems broken.

user=> (binding [*data-readers* {'inst #'clojure.instant/read-instant-timestamp}] (read-string "#inst \"2012Z\""))
#inst "2011-12-31T19:000000000000000-05:00"

user=> (binding [data-readers {'inst #'clojure.instant/read-instant-timestamp}] (read-string "#inst \"2012-01-01T01:23:45.678+00:00\""))
#inst "2011-12-31T20:267800000000000-05:00"

user=> (java.sql.Timestamp. 0)
#inst "1969-12-31T19:000000000000000-05:00"

The implementations of the print-methods for Data, GregorianCalendar and Timestamp do too much string manipulation. I suggest doing some refactoring. (Patch coming soon.)

Also, the documentation needs some updating. clojure.instant/read-instant-date, etc. mention instant-reader but I think that mechanism was generalized as data-readers.

[CLJ-927] default tagged literal reader

Fri, 1 Mar 2013 09:49:21 -0600

With data reader support, it's impossible to write a program to read an arbitrary stream of Clojure forms. For example, the following code will fail with the current 1.4.0-beta1 tagged literal support:

#point [0 2]

It might be enough to require that the read side define a reader for point, but what if we do not wish to require that both sides of the conversation know about the #point tag beforehand? Using the identity function as a default allows the reader to handle the literal form as is even when it doesn't recognize a tag (or even care to translate it).

The change from the current behavior is that missing tagged literal parsers are no longer error conditions.

[CLJ-925] rand-nth throws on empty list

Tue, 14 Aug 2012 13:35:28 -0500

rand-nth throws when given an empty list.

Solution is to either call seq on parameter, or to supply nil as a not-found parameter in call to nth. Patch fir latter fix included.

[CLJ-924] Error reporting of invalid digit in unicode character literal

Fri, 23 Mar 2012 08:40:35 -0500

I ran across the following code when reading unicode character literals in readUnicodeChar(String token, int offset, int length, int base)

 
int d = Character.digit(token.charAt(i), base);
if(d == -1)
    throw new IllegalArgumentException("Invalid digit: " + (char) d);

Casting -1 to a char doesn't seem to produce anything useful. I'm guessing the appropriate code might look like

 
int d = Character.digit(token.charAt(i), base);
if(d == -1)
    throw new IllegalArgumentException("Invalid digit: " + token.charAt(i));

For comparison, the code in the other readUnicodeCharacter used when reading strings handles this correctly with:

int d = Character.digit(ch, base);
if(d == -1)
    throw new IllegalArgumentException("Invalid digit: " + (char) ch);

[CLJ-923] Reading ratios prefixed by + is not working

Sat, 18 Aug 2012 07:12:53 -0500

In general Clojure's number types can be read prefixed with either a +
or - and this seems to work correctly for reading integers and floats.
In the case of ratios however things break down when ratios are
prefixed with a +.

The ratio pattern in LispReader.java does match on ratios starting
with both + and - but matchNumber fails on ratios prefixed with +
because it ends up calling "new BigInteger(m.group(1))" and it turns
out the constructor for BigInteger has no problems with negative
numbers but it doesn't like numbers prefixed by a +.

[CLJ-921] Ant 1.8 gives warning about 'includeantruntime' when building Clojure

Fri, 1 Mar 2013 12:47:01 -0600

I'm building Clojure locally with Ant 1.8.2. I get a warning:

compile-java:
[javac] /Users/miner/cljproj/clojure/build.xml:39: warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds

A good explanation is available here:

http://stackoverflow.com/questions/5103384/ant-warning-includeantruntime-was-not-set

The simple fix is to add an attribute to the javac task: includeAntRuntime="false".

[CLJ-920] Adds support for FreeDesktop's xdg-open in clojure.java.browse/browse-url.

Fri, 1 Mar 2013 12:47:01 -0600

This patch allows environments that support FreeDesktop to browse a URL in their default browser. This is important because unless the desktop environment bridges to Java (like Gnome does) the URL will be opened in a Swing window, which is not always desired.

See: https://github.com/clojure/clojure/pull/14

[CLJ-917] clojure.core/definterface is not included in the API docs

Sat, 20 Oct 2012 09:53:42 -0500

Is definterface meant to be a public API? If yes, then it needs a docstring.

[CLJ-916] into loses metadata

Sat, 18 Aug 2012 07:50:41 -0500

The into fn loses metadata.

I'm seeing some team members (myself included) rely on metadata. Metadata has been incredibly useful in some cases, however the silent destruction of metadata by core clojure fns (into, walk, etc) have been a source of increasing complexity and confusion.

A team member could start relying on a 3rd party library that used 'into'. Actually, the into fn could essentially be added to the code base at any time in many ways. Wrt metadata the potential for incidental complexity increases exponentially as more developers and libraries enter the mix.

One of the reasons Clojure has worked for us so well is because it has greatly reduced incidental complexity.
IMHO the 'into metadata bug' seriously limits the usefulness of metadata and would love to see the into fn fixed in 1.4.

[CLJ-914] Add support for UUID literals using tagged literal capability.

Fri, 1 Mar 2013 12:46:58 -0600

Using the tagged literal facility added in Clojure 1.4-alpha4, add support for a UUID literal of the form:

#uuid "550e8400-e29b-41d4-a716-446655440000"

;=> #<UUID 550e8400-e29b-41d4-a716-446655440000>

The default object built with this literal would be a java.util.UUID. A print-method for this type would also be required for this enhancement.

[CLJ-910] [Patch] Allow for type-hinting the method receiver in memfn

Sat, 1 Sep 2012 08:37:48 -0500

The attached patch copies metadata given to the method name symbol of memfn to the method receiver in the expansion. That way, memfn is able to be used even for type-hinted calls resulting in a big performance win.

user> (time (dotimes [i 1000000] ((memfn intValue) 1)))
Reflection warning, NO_SOURCE_FILE:1 - call to intValue can't be resolved.
"Elapsed time: 2579.229115 msecs"
nil
user> (time (dotimes [i 1000000] ((memfn ^Number intValue) 1)))
"Elapsed time: 12.015235 msecs"
nil

[CLJ-909] Make LineNumberingPushbackReader's buffer size configurable

Sat, 18 Aug 2012 07:50:41 -0500

In some situations, it's necessary to configure the buffer size of LineNumberingPushbackReader's wrapped java.io.LineNumberReader, that gets created in the constructor. A concrete problem case is where you want to avoid doing reads from the underlying Reader whenever possible, so using a buffer size of 1 makes it a bit lazier. I can also imagine cases where you'd want to increase the buffer from java.io.BufferedReader's 8192-char default, but I haven't dealt with that one directly.

There's no good way to do this by subclassing LineNumberingPushbackReader, since all the action happens in the constructors: those of java.io.LineNumberReader and the superclass of LineNumberingPushbackReader, which is java.io.PushbackReader. So my current workaround is to copy the entirety of LineNumberingPushbackReader, change the name, and add a constructor. Having LineNumberingPushbackReader support this directly would be great.

Both java.io.LineNumberReader and java.io.PushbackReader have constructors that accept the buffer size as the second argument, so it seems very reasonable to me to add a similar constructor for LineNumberingPushbackReader.

[CLJ-905] clojure.string/replace-first treats \ and $ specially when match is a string, unlike clojure.string/replace

Fri, 1 Mar 2013 12:47:03 -0600

clojure.string/replace only gives special treatment to replacement string when match is a regex pattern. clojure.string/replace-first does so in those cases, but also when match is a string to be matched literally. For example, these cases are not consistent with each other:

user=> (require '[clojure.string :as str])
nil
user=> (str/replace "food" "o" "$")
"f$$d"
user=> (str/replace-first "food" "o" "$")
java.lang.StringIndexOutOfBoundsException: String index out of range: 1 (NO_SOURCE_FILE:0)

[CLJ-904] Document read-eval in read, read-string

Fri, 22 Feb 2013 09:02:45 -0600

Even though the #=() reader syntax is "unofficial", *read-eval* should be documented in the appropriate API functions – this is a serious security problem for anyone accepting serialized Clojure data structures. E.g., a system service reading a config file, a server accepting an API request.

[CLJ-902] doc macro broken for namespaces

Fri, 1 Mar 2013 09:49:20 -0600

Example:

Clojure 1.3.0
user=> (doc clojure.pprint)
ClassNotFoundException clojure.pprint java.net.URLClassLoader$1.run (URLClassLoader.java:366)

It appears it is not safe to call resolve on a symbol representing a namespace; you get the error above. FWIW, I seem to have resolved the problem (see attached diff) by moving the find-ns clause above the resolve clause (in the cond); also the reference to namespace-doc needs to be var-quoted since namespace-doc is private.

[CLJ-898] Agent sends consume heap

Fri, 1 Mar 2013 12:47:00 -0600

Simple demonstration:

(defn update [state]
  (send *agent* update)
  (inc state))

(def a (agent 1))

(send a update)

On Clojure 1.2.1, this runs forever with no problem. On 1.3.0, it throws "java.lang.OutOfMemoryError: Java heap space."

The problem appears to be clojure.core/binding-conveyor-fn: each send creates a new Var binding frame, and nested send creates an infinite stack of frames.

Also discussed at https://groups.google.com/d/topic/clojure/1qUNPZv3OYA/discussion

[CLJ-897] deftype error message is misleading not useful

Fri, 15 Jun 2012 11:09:26 -0500

If you forget to include the argument vector for deftype, i.e.

(deftype second-request-handler
HttpServer.RequestHandler
(canRespond [this request] true)
(getResponse [this request] nil))

which should be...

(deftype second-request-handler []
HttpServer.RequestHandler
(canRespond [this request] true)
(getResponse [this request] nil))

I get the error message..

Don't know how to create ISeq from: clojure.lang.Symbol (main.clj:1)

When in fact the error is coming from (second-request-handler.clj:3). Can this error message be improved and give the actually location of the error?

[CLJ-895] Collection.toArray implementations do not conform to Java API docs

Fri, 1 Mar 2013 12:47:07 -0600

Per http://docs.oracle.com/javase/6/docs/api/index.html?java/util/Collections.html, Collection.toArray(T []) implements must allocate an array of type T[], not Object[]. This will cause type-casty code to break. Not often a problem in Clojure, but e.g. it makes Clojure defrecords unprintable from the JRuby console.

There is also a chance to DRY up some common code, as the six places that have this problem should all call an RT helper.

This also fixes toArray(T[]) for PersistentQueue when the passed array has the same length as the queue.

[CLJ-893] crafted `vec' call allows created vector to be mutated

Fri, 18 May 2012 12:32:03 -0500

user> (let [a (to-array (repeat 31 0)), v (vec a)]
        [(v 2) (do (aset a 2 'no) (v 2))])
[0 no]
user> (let [a (to-array (repeat 33 0)), v (vec a)]
        [(v 2) (do (aset a 2 'no) (v 2))])
[0 0]

While a relaxation of when different changes to the environment are made may impact the resulting value of the vector, as it is with lazy seqs, it oughtn't be possible to get two different results for the same access, just as with lazy seqs.

[CLJ-892] sort changes its argument, if a Java array

Fri, 18 May 2012 12:35:48 -0500

user> (let [a (to-array [32 11])]
(prn (seq a))
(sort a)
(prn (seq a)))
(32 11)
(11 32)
nil

Where the second line printed ought to be the same as the first.

[CLJ-890] Tagged literals in reader

Fri, 1 Mar 2013 12:47:02 -0600

See http://dev.clojure.org/display/design/Tagged+Literals

[CLJ-886] java.io/do-copy can garble multibyte characters

Fri, 23 Mar 2012 08:40:35 -0500

See comments in fix:

(defmethod do-copy [InputStream Writer] [#^InputStream input #^Writer output opts]
;; WRONG! if the buffer boundry falls in the middle of a multibyte character, we will get garbled results.
#_
(let [#^"[B" buffer (make-array Byte/TYPE (buffer-size opts))]
(loop []
(let [size (.read input buffer)]
(when (pos? size)
(let [chars (.toCharArray (String. buffer 0 size (encoding opts)))]
(do (.write output chars)
(recur)))))))
;; here we decode the characters before stuffing them into the buffer
(let [#^"[C" buffer (make-array Character/TYPE (buffer-size opts))
in (InputStreamReader. input (encoding opts))]
(loop []
(let [size (.read in buffer 0 (alength buffer))]
(if (pos? size)
(do (.write output buffer 0 size)
(recur)))))))

[CLJ-885] clojure.java.io/Coercions doesn't handle URL-escaping

Fri, 9 Dec 2011 10:00:59 -0600

clojure.java.io/Coercions implementations for URL -> File and File -> URL don't take URL escaping into account, and I think they should.

This breaks things like slurping a resource file that has spaces in the path.

Example behavior here: https://gist.github.com/1398972

I will post a link to the clojure-dev list discussion in the comments once I have the link for this ticket to post there.

[CLJ-882] non-dynamic earmuff var warning would be better with file name and line number

Fri, 2 Dec 2011 09:03:00 -0600

If a var name looks like it's meant to be dynamic but isn't declared so, Clojure 1.3 generates this warning:

Warning: *some-var* not declared dynamic and thus is not dynamically rebindable, but its name suggests otherwise. 
Please either indicate ^:dynamic *some-var* or change the name.

When porting a project to Clojure 1.3, one of the project's dependencies may cause the warning, in which case it can be difficult to tell which. The code causing the warning may only exist inside a .jar and possibly only in a .class file inside that. This means significant work is required even to know which project needs to be told their code doesn't work on Clojure 1.3.

Much less work would be required if the warning included the filename and line number causing the warning. The compiler has easy access to that information when it generates the warning.

I suggest just adding these to the end so that the warning would look like:

Warning: *some-var* not declared dynamic and thus is not dynamically rebindable, but its name suggests otherwise. 
Please either indicate ^:dynamic *some-var* or change the name. (out/of-date/code.clj:210)

[CLJ-881] Problem with the "cl-format" function from the clojure.pprint

Fri, 18 May 2012 20:37:04 -0500

Let's see the following scenario:

vdim@home:~/clojure$ git log -1
commit ba930d95fc3a4a78c5bd6756ea483c9dac681618
Author: Rich Hickey <richhickey@gmail.com>
Date: Sun Oct 30 10:44:55 2011 -0400

inline equiv in variadic =
vdim@home:~/clojure$ rlwrap java -cp clojure-1.4.0-master-SNAPSHOT.jar clojure.main
Clojure 1.4.0-master-SNAPSHOT
user=> (use 'clojure.pprint)
nil
user=> (cl-format nil "~12,10F" 1.00000000074)
"1.0000000007"
user=> (cl-format nil "~12,10F" 1.00000000076)
NumberFormatException For input string: "10000000007" java.lang.NumberFormatException.forInputString (NumberFormatException.java:65)
user=>

The exception is caused from round-str function (cl-format.clj) where
my number (100000000076) is coerced to an Integer (see line with Integer/valueOf code
into this function).

Is this normal behaviour?

See patch with tests and my suggestion for solving this problem.

[CLJ-879] Allow :require to support a :refer clause

Fri, 17 Feb 2012 14:18:28 -0600

There's been discussion previously about the complexity of the ns
macro. In particular the fact that :use causes all vars to be referred
by default is widely seen as unfortunate, and the distinction between
use and require is a source of conceptual overhead for people new to
the language.

We can't change the fact that :use refers everything by default
without breaking lots of existing code. But it would be possible to
enhance :require to support referring specified vars, leaving us free
to deprecate or otherwise discourage the use of :use.

Clojure-dev thread discussing this: http://groups.google.com/group/clojure-dev/browse_thread/thread/91b708ddb909affd

[CLJ-876] #^:dynamic vars declared in a nested form are not immediately dynamic

Fri, 9 Dec 2011 10:00:59 -0600

http://groups.google.com/group/clojure/browse_thread/thread/890202da5db0fe1/e34819de71c6ea24?hl=en&lnk=gst&q=micah#e34819de71c6ea24

The following snippet throws an error stating that p is unbound.

(list
(declare ^:dynamic p)
(defn q [] @p))
(binding [p (atom 10)]
(q))

[CLJ-874] defrecord factory inaccessibly from within type implementation

Fri, 2 Dec 2011 09:03:00 -0600

Discovered this issue working through https://github.com/relevance/labrepl when trying to use the new factory sytax for records:

(defprotocol Player
(choose [p])
(update-strategy [p me you]))

(defrecord Mean [last-winner]
  Player
  (choose [_] (if last-winner last-winner (random-choice)))
  (update-strategy [_ me you] (->Mean (when (iwon? me you) me))))

Notice that Mean returns a new instance with a different strategy. However, the factory methods are not defined until after the record has been created thus this results in a syntax error. To fix this I updated the macro to declare the factory methods before the record is emitted.

[CLJ-872] Add support for property lookup

Fri, 1 Mar 2013 12:46:59 -0600

Add support for property lookups to match functionality introduced in ClojureScript with ~~CLJS-89~~.

This is a breaking change for Clojure with record/type fields that start with "-".

[CLJ-871] instant literal

Fri, 1 Mar 2013 12:47:08 -0600

See http://dev.clojure.org/pages/viewpage.action?pageId=950382 for design discussion.

[CLJ-870] clojure.string/replace behaves unexpectedly when \ or $ are part of the result string

Sat, 18 Aug 2012 07:50:41 -0500

clojure.string/replace uses javas replace function to do it's work, the replace function has the tricky habit of 'double evaluating' the replacement string (third argument). This means that every \ in the string (so i.e. "
") is evaluated by the java code behind replace.

Since this behavior isn't documented it can lead to confusing errors, for example (made up semi real world example to explain the issue):

(clojure.string/replace "c:/windows/" #"/" "\\")

This should replace all unix folder separators with windows separators, this crashes with a index out of bound exemption since java tries to evaluate "
" as a semi regexp.

(println (str "\"" (clojure.string/replace "my string with \\ and \" in it" #"[\"\\]" (fn [x] (str "\\" x))) "\""))

The expected result would be:

"my string with \\ and \" in it"

the actual result is:

"my string with \ and " in it"

This should return an 'escaped' string, it does not since the 'double evaluation' of the return string results in \\\\ being reduced to
again.

[CLJ-868] core min and max should behave predictably when args include NaN

Fri, 9 Dec 2011 10:01:00 -0600

The min and max functions in clojure.core behave unpredictably when one or more of their arguments is Float/NaN or Double/NaN. This is because the current implementation assumes that > provides a total ordering, but this is not the case when NaN is added to the mix. This is an unfortunate fact of life when dealing with IEEE floating point numbers.

See also the recent mailing list thread "clojure.core/max and NaN".

May be related to issue ~~CLJ-738~~.

[CLJ-867] Records of different types with the same data have the same hashcodes, even though they are not considered to be equal

Fri, 18 May 2012 20:37:11 -0500

Records which contain the same field values are not considered to be equal, but the record type is not currently included in the hash. This means that if an heterogenous map contains records of different types, where the fields aren't necessarily distinct, there is a high likelyhood of hash collisions.

I propose that the record type should be included in the hash code algorithm for records. There should be no expectation that unequal records of different types should have the same hash-code.

user=> (hash (->A 1))
1013911913
user=> (hash (->B 1))
1013911913
user=> (= (~~>A 1) (~~>B 1))
false

This issue also affects ClojureScript. But see CLJS-97, as ClojureScript also has an issue with record equality.

[CLJ-861] PersistentHashMap uses a hashing function that is incongruent with the equality function it uses

Fri, 1 Mar 2013 12:46:59 -0600

PersistentHashMap hashes its keys with Util.hash which simply calls Object.hashCode, but it compares its keys for equality using Util.equiv. This means:

user=> (clojure.lang.Util/equiv (Integer. -1) (Long. -1))
true
user=> (= (clojure.lang.Util/hash (Integer. -1)) (clojure.lang.Util/hash (Long. -1)))
false

which breaks the contract of a hash table (keys that are equal should hash to values that are equal).

The following bad behavior results:

user=> (def bad-map (clojure.lang.PersistentHashMap/create {(Long. -1) :here}))
#'user/bad-map
user=> (contains? bad-map (Integer. -1))
false
user=> (get bad-map (Integer. -1))
nil
user=> (= bad-map (clojure.lang.PersistentHashMap/create {(Integer. -1) :here}))
false

Compared to:

user=> (def bad-map (clojure.lang.PersistentHashMap/create {(Long. 0) :here}))
#'user/bad-map
user=> (contains? bad-map (Integer. 0))
true
user=> (get bad-map (Integer. 0))
:here
user=> (= bad-map (clojure.lang.PersistentHashMap/create {(Long. 0) :here}))
true

This bug also infects PersistentHashSet:

user=> #{(Long. 0) (Integer. 0)}
IllegalArgumentException Duplicate key: 0  clojure.lang.PersistentHashSet.createWithCheck (PersistentHashSet.java:56)
user=> #{(Long. -1) (Integer. -1)}
#{-1 -1}
user=> (contains? #{(Long. 0)} (Integer. 0))
true
user=> (contains? #{(Long. -1)} (Integer. -1))
false

[CLJ-860] Add ability to disable locals clearing

Fri, 1 Mar 2013 12:46:59 -0600

When using a debugger, it is useful to be able to see all variable values. Locals clearing reduces the number of variabls that are non-nil, and makes uncertain whether nil values are real or an artifact of locals clearing.

Please add a mechanism for disabling locals clearing.

The attached patch does this by introducing the disable-locals-clearing var, and using it to initialise the canBeCleared field of LocalBinding.

[CLJ-857] CLJ-791 caused some compiler breakage

Tue, 25 Oct 2011 17:32:26 -0500

Stuart Halloway reports:

Here's a short example showing the problem (against master):

(require '[clojure.java.jdbc :as jdbc])
(set! *warn-on-reflection* true)
(jdbc/resultset-seq
 (-> (jdbc/connection)
    (.getMetadata)
    (.getColumns nil nil "foo" nil)))

Reflection warning, NO_SOURCE_PATH:8 - reference to field getMetadata can't be resolved.

NullPointerException
       clojure.lang.Compiler.expandArrayClassname (Compiler.java:2265)
       clojure.lang.Compiler.signatureString (Compiler.java:2275)
       clojure.lang.Compiler$InstanceMethodExpr.<init> (Compiler.java:1366)
       clojure.lang.Compiler$HostExpr$Parser.parse (Compiler.java:912)
       clojure.lang.Compiler.analyzeSeq (Compiler.java:6437)
       clojure.lang.Compiler.analyze (Compiler.java:6244)

The NPE does not occur if the call the getMetadata is in a simpler expression.

[CLJ-856] Building Clojure (git head) on JDK7 fails

Fri, 1 Mar 2013 12:47:10 -0600

lnostdal@blackbox:~/programming/clojure$ ant
Buildfile: /home/lnostdal/programming/clojure/build.xml

clean:
[delete] Deleting directory /home/lnostdal/programming/clojure/target
[delete] Deleting /home/lnostdal/programming/clojure/clojure-1.4.0-master-SNAPSHOT.jar
[delete] Deleting /home/lnostdal/programming/clojure/clojure.jar

init:
[mkdir] Created dir: /home/lnostdal/programming/clojure/target/classes
[mkdir] Created dir: /home/lnostdal/programming/clojure/target/classes/clojure

compile-java:
[javac] /home/lnostdal/programming/clojure/build.xml:39: warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds
[javac] Compiling 144 source files to /home/lnostdal/programming/clojure/target/classes
[javac] javac: target release 1.5 conflicts with default source release 1.7

BUILD FAILED
/home/lnostdal/programming/clojure/build.xml:39: Compile failed; see the compiler error output for details.

Total time: 0 seconds

lnostdal@blackbox:~/programming/clojure$ emacs -nw build.xml
lnostdal@blackbox:~/programming/clojure$ git diff
diff --git a/build.xml b/build.xml
index a693e6d..c05adf8 100644
— a/build.xml
+++ b/build.xml
@@ -36,7 +36,7 @@
<target name="compile-java" depends="init"
description="Compile Java sources.">
<javac srcdir="${jsrc}" destdir="${build}" includeJavaRuntime="yes"

debug="true" target="1.5"/>
+ debug="true"/>
</target>

<target name="compile-clojure"

lnostdal@blackbox:~/programming/clojure$ ant
...
...

..and it builds OK. I don't understand the Java tools very well, but I decided to try removing "target" based on what I found here: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6856165

[CLJ-855] catch receives a RuntimeException rather than the expected checked exception

Fri, 1 Mar 2013 12:47:00 -0600

Expressions passed to try that trigger the use of clojure.lang.Reflector result in their thrown checked exceptions being wrapped in RuntimeException. As a result, the subsequent set of catches won't switch on the expected checked exception.

Attached: patch for regression test that exposes the problem

(defn- get-exception [expression]
  (try (eval expression)
    nil
    (catch java.lang.Throwable t
      t)))

(deftest catch-receives-checked-exception
  (are [expression expected-exception] (= expected-exception
                                          (type (get-exception expression)))
    "Eh, I'm pretty safe" nil
    '(java.io.FileReader. "CAFEBABEx0/idonotexist") java.io.FileNotFoundException)) ; fails

Clojure ML Thread: https://groups.google.com/forum/#!topic/clojure/I5l1YHVMgkI/discussion
Introduced: https://github.com/clojure/clojure/commit/8fda34e4c77cac079b711da59d5fe49b74605553

[CLJ-854] flatten doc incorrect

Fri, 9 Dec 2011 10:01:00 -0600

Usage: (flatten x)
Takes any nested combination of sequential things (lists, vectors,
etc.) and returns their contents as a single, flat sequence.
(flatten nil) returns nil.

doc string for (flatten nil) should be removed / altered.

(flatten nil)
;=> ()

[CLJ-853] Typo in the doc of get-in function

Tue, 25 Oct 2011 17:50:09 -0500

In " where ks is a sequence of ke(ys.", "ke(ys" should be "keys".

[CLJ-852] IllegalArgumentException thrown when defining a var whose value is calculated with a primitive fn.

Fri, 23 Mar 2012 08:40:35 -0500

Note the following stacktrace line numbers are from the latest 1.4-snapshot, though this happens on 1.3 as well.

Example:

user=> (defn foo ^long [^long x] x)
#'user/foo
user=> (def x (inc (foo 10)))
CompilerException java.lang.IllegalArgumentException: Unable to resolve classname: long, compiling:(NO_SOURCE_PATH:2) 
user=> (pst)
CompilerException java.lang.IllegalArgumentException: Unable to resolve classname: long, compiling:(NO_SOURCE_PATH:2)
	clojure.lang.Compiler.analyzeSeq (Compiler.java:6444)
	clojure.lang.Compiler.analyze (Compiler.java:6244)
	clojure.lang.Compiler.analyze (Compiler.java:6205)
	clojure.lang.Compiler.analyzeSeq (Compiler.java:6432)
	clojure.lang.Compiler.analyze (Compiler.java:6244)
	clojure.lang.Compiler.access$100 (Compiler.java:37)
	clojure.lang.Compiler$DefExpr$Parser.parse (Compiler.java:492)
	clojure.lang.Compiler.analyzeSeq (Compiler.java:6437)
	clojure.lang.Compiler.analyze (Compiler.java:6244)
	clojure.lang.Compiler.analyze (Compiler.java:6205)
	clojure.lang.Compiler.eval (Compiler.java:6497)
	clojure.lang.Compiler.eval (Compiler.java:6459)
Caused by:
IllegalArgumentException Unable to resolve classname: long
	clojure.lang.Compiler$HostExpr.tagToClass (Compiler.java:1003)
	clojure.lang.Compiler$InvokeExpr.getJavaClass (Compiler.java:3474)
	clojure.lang.Compiler.getMatchingParams (Compiler.java:2304)
	clojure.lang.Compiler$StaticMethodExpr.<init> (Compiler.java:1510)
	clojure.lang.Compiler$HostExpr$Parser.parse (Compiler.java:910)
	clojure.lang.Compiler.analyzeSeq (Compiler.java:6437)
	clojure.lang.Compiler.analyze (Compiler.java:6244)

Note though that the following works fine:

user=> (def x (foo (inc 10)))
#'user/x

[CLJ-847] mapv, filterv

Fri, 2 Dec 2011 10:23:25 -0600

Skip the intermediate sequence step when you know the result you want is a vector, i.e.

(defn mapv
  ([f coll]
     (-> (reduce (fn [v o] (conj! v (f o))) (transient []) coll)
         persistent!)))

(defn filterv
  [pred coll]
  (when-let [s (seq coll)]
    (-> (reduce (fn [v o] (if (pred o) (conj! v o) v))
                (transient [])
                coll)
        persistent!)))

[CLJ-846] Javadoc does not detect 1.7 when setting core-java-api

Fri, 1 Mar 2013 12:47:00 -0600

When initializing core-java-api, javadoc.clj checks whether the java specification version is 1.5; if not, it uses a url for the 1.6 docs. Unfortunately, this won't find documentation for new in 1.7 classes (such as those in the java.nio.file package).

[CLJ-845] Unexpected interaction between protocol extension and namespaced method keyword/symbols

Fri, 1 Mar 2013 12:47:03 -0600

If the keywords of a protocol's method map are namespaced, the map is accepted, but lookup fails since lookup uses non-namespaced keywords.

See ~~TLOG-4~~ for an actual case of this being an issue.

Work-around for namespaced keywords with extend:
don't use namespaced keywords

Work-around for syntax-quoting with extend-type or extend-protocol:
use extend with non-namespaced keywords

Possible solutions:

Inside extend, remove namespace of keywords
or
- Inside extend, error on namespaced keywords.
- Inside emit-hinted-impl, only grab name portion of symbols before converting to keyword.

[CLJ-844] NPE calling keyword on map from bean

Fri, 15 Jun 2012 11:09:26 -0500

Calling a keyword on a map returned from clojure.core/bean causes a null pointer exception if the keyword is not a key in the map:

user=> (:a (bean {}))
java.lang.NullPointerException (NO_SOURCE_FILE:0)
user=> (.printStackTrace *e)
Caused by: java.lang.NullPointerException
at clojure.core$bean$v__4765.invoke(core_proxy.clj:385)
at clojure.core$bean$fn__4786.invoke(core_proxy.clj:394)
at clojure.core.proxy$clojure.lang.APersistentMap$0.valAt(Unknown Source)
at clojure.lang.KeywordLookupSite.fault(KeywordLookupSite.java:33)
at user$eval1062.invoke(NO_SOURCE_FILE:7)
at clojure.lang.Compiler.eval(Compiler.java:5424)
... 9 more

The object returned by bean claims to be an APersistentMap FWIW:

user=> (class (bean {}))
clojure.core.proxy$clojure.lang.APersistentMap$0

[CLJ-843] clojure.lang.RT should provide a loadLibrary static method

Fri, 2 Dec 2011 09:03:00 -0600

Right now, loading native libraries in Clojure doesn't work as expected because those libraries are loaded into the classloader of the invoking class (that is, Clojure's own classloader).

This problem has been discussed on the mailing list and a patch has been welcomed by Rich -

https://groups.google.com/group/clojure/browse_thread/thread/aa72e43091ec3228?pli=1
https://groups.google.com/forum/#!topic/clojure-dev/awe7-yeieIM
https://groups.google.com/forum/?hl=en#!topic/clojure-dev/OFQhDKHTyrw

To fix this, I am attaching a trivial patch that implements loadLibrary in RT.

[CLJ-839] contains? does not work with java.util.Set

Fri, 9 Dec 2011 10:01:00 -0600

contains? does support j.u.Map, but not j.u.Set. However it works with Clojure sets.

[CLJ-838] dev.clojure.org/display/doc/1. 3 renders badly

Fri, 1 Mar 2013 12:47:01 -0600

The page http://dev.clojure.org/display/doc/1.3 has markup issues:

*earmuffs* become bold
clearly [ ] must mean something special, 'cause they all turn pink.
presumably there's some way to make confluence use monospace for code snippets.
I'm sure confluence has some way to mark headings, but It doesn't look like "==" is it.
I'd like to evict the "frowning face" from ~~CLJ-751~~'s clj-format example.
2.29 seems to have suffered some encoding debacle, though I'm not quite sure what happened.

Further discussion revealed that this was just a copy/paste of changes.txt in the source repository. Discussions on clojure-dev suggested the idea of recoding changes.txt to changes.md and recoding it as proper markdown so that it will be rendered nicely by github.

This would make http://dev.clojure.org/display/doc/1.3 obsolete, its contents could be replaced by a link to 'changes.md' on github. That makes more sense than maintaining two copies of the document in mutually incompatible markups (markdown and whatever confluence uses).

See also the following clojure-dev thread:

http://groups.google.com/group/clojure-dev/browse_thread/thread/ecf65c4e50d3fd76

[CLJ-837] java.lang.VerifyError when compiling deftype or defrecord with argument name starting with double underscore characters.

Fri, 9 Dec 2011 10:01:00 -0600

The minimal test to trigger the verification error is :

(deftype t [__])
or
(defrecord r [__])

It works fine in clojure 1.2, 1.2.1

Works fine with one underscore.

Output from REPL:

user=> (defrecord r [__])
CompilerException java.lang.VerifyError: (class: user/r, method: create signature: (Lclojure/lang/IPersistentMap;)Luser/r Expecting to find object/array on stack, compiling:(NO_SOURCE_PATH:2)

Stack trace from slime session:

(class: clojure/data/priority_map/r, method: create signature: (Lclojure/lang/IPersistentMap;)Lclojure/data/priority_map/r Expecting to find object/array on stack
[Thrown class java.lang.VerifyError]

Restarts:
0: [QUIT] Quit to the SLIME top level

Backtrace:
0: java.lang.Class.forName0(Native Method)
1: java.lang.Class.forName(Class.java:247)
2: clojure.lang.RT.classForName(RT.java:2013)
3: clojure.lang.Compiler$HostExpr.maybeClass(Compiler.java:929)
4: clojure.lang.Compiler$HostExpr.access$400(Compiler.java:710)
5: clojure.lang.Compiler$NewExpr$Parser.parse(Compiler.java:2391)
6: clojure.lang.Compiler.analyzeSeq(Compiler.java:6368)
7: clojure.lang.Compiler.analyze(Compiler.java:6175)
8: clojure.lang.Compiler.analyze(Compiler.java:6136)
9: clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5531)
10: clojure.lang.Compiler$FnMethod.parse(Compiler.java:4967)
[No Locals]
11: clojure.lang.Compiler$FnExpr.parse(Compiler.java:3588)
12: clojure.lang.Compiler.analyzeSeq(Compiler.java:6366)
13: clojure.lang.Compiler.analyze(Compiler.java:6175)
14: clojure.lang.Compiler.analyzeSeq(Compiler.java:6356)
15: clojure.lang.Compiler.analyze(Compiler.java:6175)
16: clojure.lang.Compiler.access$100(Compiler.java:37)
17: clojure.lang.Compiler$DefExpr$Parser.parse(Compiler.java:492)
18: clojure.lang.Compiler.analyzeSeq(Compiler.java:6368)
19: clojure.lang.Compiler.analyze(Compiler.java:6175)
20: clojure.lang.Compiler.analyzeSeq(Compiler.java:6356)
21: clojure.lang.Compiler.analyze(Compiler.java:6175)
22: clojure.lang.Compiler.analyze(Compiler.java:6136)
23: clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5531)
24: clojure.lang.Compiler$LetExpr$Parser.parse(Compiler.java:5832)
25: clojure.lang.Compiler.analyzeSeq(Compiler.java:6368)
26: clojure.lang.Compiler.analyze(Compiler.java:6175)
27: clojure.lang.Compiler.analyze(Compiler.java:6136)
28: clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5531)
29: clojure.lang.Compiler$FnMethod.parse(Compiler.java:4967)
30: clojure.lang.Compiler$FnExpr.parse(Compiler.java:3588)
31: clojure.lang.Compiler.analyzeSeq(Compiler.java:6366)
32: clojure.lang.Compiler.analyze(Compiler.java:6175)
33: clojure.lang.Compiler.eval(Compiler.java:6421)
34: clojure.lang.Compiler.eval(Compiler.java:6390)
35: clojure.core$eval.invoke(core.clj:2795)
36: swank.commands.basic$eval_region.invoke(basic.clj:47)
37: swank.commands.basic$eval_region.invoke(basic.clj:37)
38: swank.commands.basic$eval764$listener_eval__765.invoke(basic.clj:71)
39: clojure.lang.Var.invoke(Var.java:401)
40: clojure.data.priority_map$eval2759.invoke(NO_SOURCE_FILE)
41: clojure.lang.Compiler.eval(Compiler.java:6424)
42: clojure.lang.Compiler.eval(Compiler.java:6390)
43: clojure.core$eval.invoke(core.clj:2795)
44: swank.core$eval_in_emacs_package.invoke(core.clj:92)
45: swank.core$eval_for_emacs.invoke(core.clj:239)
46: clojure.lang.Var.invoke(Var.java:409)
47: clojure.lang.AFn.applyToHelper(AFn.java:167)
48: clojure.lang.Var.applyTo(Var.java:518)
49: clojure.core$apply.invoke(core.clj:600)
50: swank.core$eval_from_control.invoke(core.clj:99)
[No Locals]
51: swank.core$eval_loop.invoke(core.clj:104)
52: swank.core$spawn_repl_thread$fn_529$fn_530.invoke(core.clj:309)
53: clojure.lang.AFn.applyToHelper(AFn.java:159)
54: clojure.lang.AFn.applyTo(AFn.java:151)
55: clojure.core$apply.invoke(core.clj:600)
56: swank.core$spawn_repl_thread$fn__529.doInvoke(core.clj:306)
57: clojure.lang.RestFn.invoke(RestFn.java:397)
58: clojure.lang.AFn.run(AFn.java:24)
59: java.lang.Thread.run(Thread.java:680)

[CLJ-836] BigInt optimization breaks "obvious" math

Fri, 23 Sep 2011 16:00:06 -0500

BigInt optimization seems seriously broken:

user=> (def a 1N)
#'user/a
user=> (* (+ a 10000000000000000) (+ a 10000000000000000))
ArithmeticException integer overflow
clojure.lang.Numbers.throwIntOverflow (Numbers.java:1374)

A BigInt is optimized back to a long and then overflows which is not
what happened in Beta1 and earlier.

[CLJ-833] Add boilerplate documentation to ->Foo and map->Foo functions produced by defrecord and deftype

Fri, 30 Mar 2012 09:16:31 -0500

The functions implicitly defined by defrecord and deftype (->Foo and map->Foo, discussed here and implemented via ~~CLJ-374~~) have no documentation.

Latest patch:

1. Adds docstrings to the generated constructor functions
2. Adds a paragraph to deftype/defrecord docstrings
3. Adds tests to assert that the docstrings exist

[CLJ-832] reify implements IObj but nowhere states so

Fri, 9 Dec 2011 10:00:59 -0600

reify does implement clojure.lang.IObj but nowhere states so. The attached patch fixes the docstring and adds an example how metadata is transferred from the reify form to the object.

[CLJ-831] await-for return value - doc fix

Fri, 30 Mar 2012 09:16:31 -0500

From using await-for and from inspecting the code, I believe the docstring is incorrect. The function does not return either nil or not-nil, but rather it returns a boolean indicator of whether the call was successful. The result comes straight from the java.util.concurrent.CountDownLatch/await call which returns: "true if the count reached zero and false if the waiting time elapsed before the count reached zero"

Latest patch changes docstring to specify await-for returns logical true or logical false.

[CLJ-830] Report source file and line number when throwing syntax-related error from core macros

Fri, 1 Mar 2013 12:47:01 -0600

If you botch or misunderstand certain macros in core, they throw exceptions with very unhelpful error messages:

=> (let [a])
#<IllegalArgumentException java.lang.IllegalArgumentException:
  let requires an even number of forms in binding vector>

=> (if-let [a 5
            b 6]
     true)
#<IllegalArgumentException java.lang.IllegalArgumentException:
  if-let requires exactly 2 forms in binding vector>

No mention of userland file/namespace or line number is in the stack trace. If this code happens to be in code being loaded via some chain of :requires, tracking it down can be way more painful than it reasonably should be.

Something like this would be much better:

#<IllegalArgumentException java.lang.IllegalArgumentException:
  let requires an even number of forms in binding vector in com.foo.namespace:80>

These errors are all thrown via the same assert-args function used by a variety of macros in clojure.core; modifying it so it emits a reasonable error message should be straightforward.

[CLJ-829] Transient hashmaps mishandle hash collisions

Fri, 1 Mar 2013 12:47:05 -0600

Clojure 1.2.1 and 1.3.0-beta1 both exhibit the following behavior:

user> (let [m (into {} (for [x (range 100000)] [(rand) (rand)]))]
(println (count (distinct (map hash (keys m)))))
((juxt count identity) (persistent!
(reduce dissoc! (transient m) (keys m)))))
99999
[2 {0.42548900739367024 0.8725039567983159}]

We create a large transient map with random keys and values, and check to see how many unique hashcodes we get. Then, we iterate over all the keys, dissoc'ing each out of the transient map. The resulting map has one element in it (wrong - it should be empty, since we dissoc'ed all the keys), and reports its count as being two (wrong - not sure whether it should be zero or one given the other breakage). As far as I can tell, each duplicated hash value is represented once in the output map, and the map's count is the number of keys that hashed to something duplicated.

The problem seems to be restricted to transients, as if we remove the transient/persistent! pair and use dissoc instead of dissoc!, the map is always empty.

Inspired by discussion at http://groups.google.com/group/clojure/browse_thread/thread/313ac122667bb4b5/c3e7faa8635403f1

[CLJ-828] clojure.core/bases returns a cons when passed a class and a Java array when passed an interface

Sat, 18 Aug 2012 09:19:35 -0500

clojure.core/bases returns a clojure.lang.Cons when called with a class as parameter, but a Java array ( [Ljava.lang.Class; ) when called with an interface. Both should return values of the same type, which I guess should be a seq.

Showing the problem at the REPL:
user=> (bases java.util.List)
#<Class[] [Ljava.lang.Class;@315b0333>
user=> (bases java.util.ArrayList)
(java.util.AbstractList java.util.List java.util.RandomAccess
java.lang.Cloneable java.io.Serializable)

I have attached a patch which calls the seq function on the else part of clojure.core/bases. Also updated the clojure.test-clojure.java-interop/test-bases test. However these test do not currently seem to run as part of the maven build. I have however run the test manually and verified that it works.

[CLJ-824] BigInt math is slow when values of a BigInt are small enough to actually be treated as Longs

Fri, 26 Aug 2011 14:45:33 -0500

When doing math ops on a BigInt, It should default to treating smaller values of BigInts as Longs when possible to improve performance, and fall through to the actual BigInteger math when necessary.

[CLJ-822] Reporting methods in clojure.test//-report should be marked dynamic

Fri, 26 Aug 2011 15:03:02 -0500

Background:
The latest Clojure 1.3 beta defaults all vars to static binding.
The clojure-maven-plugin depends on clojure.test/junit-report being dynamically bound.

Problem:
The clojure-maven-plugin cannot be used with Clojure 1.3

Solution:
Explicitly make junit-report dynamic. (see attached patch)

Rational
The design of this library assumes the reporting functions are dynamically rebind-able. See clojure.test/report, also dynamic.

[CLJ-817] print-deftype breaks when fields have dashes

Fri, 1 Mar 2013 12:46:59 -0600

user=> (deftype Foo [bar-quux])
user.Foo
user=> (def x (Foo. 1))
#'user/x 
user=> x
IllegalArgumentException No matching field found: bar-quux for class user.Foo  clojure.lang.Reflector.getInstanceField (Reflector.java:289)
#user.Foo[user=>

Printing records works fine. See this mailing list message for original report.

[CLJ-816] Transient vectors mutations leak into their source persistent vector

Fri, 1 Mar 2013 12:47:00 -0600

(let [pv (vec (range 34))]
(-> pv transient pop! pop! pop! (conj! 42))
(nth pv 31))
; returns 42 instead of 31

[CLJ-815] [Documentation] - Remove unnecessary "Alpha" labels in docstrings

Fri, 2 Sep 2011 09:41:05 -0500

From smfadi@googlemail.com on the Clojure mailing list

Just a quick question (before I forget): Is deftype/defrecord still
alpha? Or is the "Alpha - subject to change" note in the docstrings
just an oversight?

This needs some housekeeping. Here are a list of functions that are currently marked as "Alpha"

clojure.pprint/print-table
clojure.core/add-watch
clojure.core/remove-watch
clojure.core/juxt
clojure.core/transient
clojure.core/persistent!
clojure.core/conj!
clojure.core/assoc!
clojure.core/dissoc!
clojure.core/pop!
clojure.core/disj!
clojure.core/promise
clojure.core/deliver
clojure.core/defrecord (inside core_deftype)
clojure.core/deftype (inside core_deftype)
clojure.reflect/type-reflect
clojure.reflect/reflect

[CLJ-812] print-dup should not be defined for deftypes

Fri, 29 Jul 2011 10:17:42 -0500

deftypes are supposed to be relatively 'clean'. Defining print-dup on them might conflict with their other intended uses - e.g. if you use a deftype and implement IPersistentSet you can't print due to this conflict.

[CLJ-811] Support hinting arg vectors

Fri, 26 Aug 2011 14:45:55 -0500

Currently, return type hints must be on function or var names, e.g.:

(defn ^String foo [])

This is in contrast to primitive return type declarations, which must be on function arg vectors:

(defn foo ^long [])

The latter is preferred because:

Different arities of the same function can be typed differently
All of the type information for a given function hangs off of a single value (the arg vector)

For these reasons, supporting type hints on arg vectors as well is desirable. This would remove the (confusing and purely historic at this point) syntactic difference between type hints and signature declarations (with the current function/var name hinting support to be potentially deprecated and removed in the future).

As a pleasant side effect, this would disambiguate the semantics of var :tag metadata, thereby resolving CLJ-140.

[CLJ-808] In java.io, the make-parents function can't handle files without parent directory.

Fri, 29 Jul 2011 10:17:41 -0500

The make-parents function throws a null pointer exception when given a simple local directory file.

user> (io/make-parents "test")

Thrown class java.lang.NullPointerException

[CLJ-802] mod throws exception on large args

Fri, 27 May 2011 11:14:26 -0500

From http://groups.google.com/group/clojure-dev/browse_thread/thread/09718dc9c253d1ab

user=> (mod 3216478362187432 432143214)
ArithmeticException integer overflow  clojure.lang.Numbers.throwIntOverflow (Numbers.java:1374)

[CLJ-801] Protocols Should Handle Hash Collision

Tue, 21 Jun 2011 07:41:21 -0500

Protocols internal is using min-hash and throwing a collision, similar to the bug fixed in ~~CLJ-426~~.

https://groups.google.com/d/msg/clojure/0qllPii3fJY/Lile5yQPxuIJ

[CLJ-800] defrecord/deftype enhancements from 1.3.0-alpha7

Fri, 27 May 2011 14:20:38 -0500

The defrecord read/print functionality added in clojure-1.3.0-alpha7 based on ticket CLJ-374 provided a baseline semantics for the described functionality. However, there were some short-comings of the implementation that should be fixed, including:

Symbols not supported in the record/type reader form
Type forms are not performant as a result of being handled by print-dup
- This also leads to a situation where hinting is problematic
The boxClass method uses Reflector
Emission of records pulls out k/v's to create new map to build new record. Record itself should be used instead
Factory fn should not restrict definition of record/type with >20 fields (see here)

The semantics of the 1.3.0-alpha7 behavior should remain intact (save for bug fixes that open more functionality).

[CLJ-798] BigInteger is print-dup'able but not readable

Fri, 29 Jul 2011 10:17:42 -0500

Per Rich, "We should never be printing something that can't be read."

user=> (binding [*print-dup* true] (print-str (java.math.BigInteger. "1")))
"1BIGINT"
user=> (read-string *1)
NumberFormatException Invalid number: 1BIGINT  clojure.lang.LispReader.readNumber (LispReader.java:253)

This can either be resolved by removing the print-dup for BigInteger, printing it using the N notation (thus being read in as a BigInt), or adding read support for the BIGINT notation.

[CLJ-797] Longs print-dup to the Long constructor

Fri, 27 May 2011 14:20:36 -0500

user=> (binding [*print-dup* true] (print-str 1.0))
"1.0"
user=> (binding [*print-dup* true] (print-str 1))
"#=(java.lang.Long. \"1\")"

[CLJ-796] Records with fields named "values"

Fri, 1 Mar 2013 12:46:58 -0600

It looks to me like there is a problem in records when the field name "values" is used:

(defrecord Foo [values])

(= (Foo. 1)
(Foo. 1))

;; -> false

[CLJ-795] bit-clear index should be zero based

Fri, 27 May 2011 11:14:25 -0500

As posted to the mailing list: https://groups.google.com/d/topic/clojure/ky_cVkQyhNw/discussion

alpha7 introduced a regression where the bit-clear index is no longer zero based

user> clojure-version
{:major 1, :minor 3, :incremental 0, :qualifier "alpha4"}
user> (bit-clear 3 1)
1
user> (bit-clear 3 0)
2
user> (bit-clear 3 2)
3
user>
user> clojure-version
{:major 1, :minor 3, :incremental 0, :qualifier "alpha7"}
user> (bit-clear 3 1)
2
user> (bit-clear 3 0)
1
user> (bit-clear 3 2)
0

[CLJ-794] Some alpha-7 printdup functions have left-over debug messages.

Fri, 27 May 2011 11:14:25 -0500

(defmethod print-dup clojure.lang.IPersistentCollection [o, ^Writer w] (print " ipcpd ")
(defmethod print-dup clojure.lang.PersistentHashMap [o w] (print " phmpd ") (print-method o w))

[CLJ-791] Include argument type info in reflection warnings and method signatures in dispatch compilation errors

Fri, 1 Mar 2013 12:46:57 -0600

Errors like:

More than one matching method found: foo

are bad, especially when there are multiple overloads and the types of one's arguments aren't immediately obvious. In addition, reflection warnings like:

Reflection warning, %s:%d - call to %s can't be resolved

are similarly unhelpful.

The above should be modified to include as much type information as possible, i.e.:

More than one matching method found: foo(long[], int, int) and foo(long[], long, int) for arguments of type (long[], long, long)

Reflection warning, %s:%d - call to %s can't be resolved with arguments of type (clojure.lang.PersistentVector, String, int)

Such ideas were briefly discussed here.

[CLJ-789] Method resolution does not select exact signature matches over tying

Fri, 27 May 2011 11:14:25 -0500

Given 3+ Java methods:

public static boolean someMethod (int a, int b) {
    return true;
}

public static boolean someMethod (int a, long b) {
    return true;
}

public static boolean someMethod (long a, long b) {
    return true;
}

and a Clojure call that matches one of them exactly:

(SomeClass/someMethod (long 1) (long 1))

the compiler yells at us:

More than one matching method found: someMethod

It turns out that Compiler.getMatchingParams is not clearing its "tied" flag when a later signature is an exact match.

[CLJ-788] Add source and line members and getters to CompilerException

Sun, 2 Dec 2012 17:41:54 -0600

To improve the reliability and ease of using CompilerException in tooling, add source path and line getters to CompilerException.

When handling compiler exceptions programmatically, the source path and line currently have to be parsed out of the compiler exception.

[CLJ-786] The docstring for defn omits any mention of pre- and post-conditions

Fri, 9 Dec 2011 10:01:00 -0600

Currently, the doc string for defn does not mention pre- or post-conditions in either the arg list or description. I always forget where it goes.

Current doc string:

clojure.core/defn
([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?])
Macro
  Same as (def name (fn [params* ] exprs*)) or (def
    name (fn ([params* ] exprs*)+)) with any doc-string or attrs added
    to the var metadata

Attached is a patch to update defn to:

clojure.core/defn
([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?])
Macro
  Same as (def name (fn [params* ] exprs*)) or (def
    name (fn ([params* ] exprs*)+)) with any doc-string or attrs added
    to the var metadata. prepost-map defines a map with optional keys
    :pre and :post that contain collections of pre or post conditions.

[CLJ-784] Update min/max functions to take advantage of primitive math

Fri, 1 Mar 2013 12:47:08 -0600

Currently, the min and max functions are quite slow, since they don't take advantage of new primitive math.

Implement them in the same manner in which other primitive math functions are implemented for efficiency.

[CLJ-782] long cast is not checked for Object decimal types

Fri, 6 May 2011 08:49:10 -0500

E.g.:

user=> (*' Long/MAX_VALUE 100M)
922337203685477580700M
user=> (long *1)
-100
user=> (Double/valueOf Double/MAX_VALUE)
1.7976931348623157E308
user=> (long *1)
9223372036854775807

And the numbers.clj test erroneously considers truncation as correct.

[CLJ-781] Missing primitive-arg cast overloads

Fri, 6 May 2011 08:49:10 -0500

Casting from byte or short to other primitives, and casting other primitives to byte, short, or char results in superfluous boxing due to an absence of the necessary overloads in RT.

[CLJ-780] race condition in reference cache on Java 5

Fri, 1 Mar 2013 12:47:02 -0600

Map.Entry instances can have null values prior to Java 6

Test failure: http://build.clojure.org/job/test.generative/1/org.clojure$test.generative/console

Discussion: http://concurrency.markmail.org/message/pbruo2uxgur6wkoo?q=map%2Eentry+null&page=3#query:map.entry%20null+page:3+mid:z5arnbbzl2k32jda+state:results

Note that the fix must hold val in a local variable, because cache.remove will bomb if the value is null.

[CLJ-779] Document clojure.org differences between 1.2 and 1.3

Fri, 1 Mar 2013 09:49:21 -0600

Documentation at http://clojure.org should always represent the latest release version. When we ship Release.next, we need to update the documentation there to reflect the latest changes.

[CLJ-777] Release notes for 1.3

Tue, 23 Aug 2011 18:35:45 -0500

Go through issues and commit logs and assemble Release Notes

http://dev.clojure.org/display/doc/1.3

[CLJ-775] Test clojure.test-clojure.rt fails

Fri, 1 Mar 2013 12:47:06 -0600

When I run the mvn test command against Clojure built from source, I
encounter the following error in the test clojure.test-clojure.rt,
which appears to be due to the bare-rt-print function's use of the
var clojure.core/print-initialized:

{{Testing clojure.test-clojure.rt

ERROR in (rt-print-prior-to-print-initialize) (Var.java:339)
expected: (= "#\"foo\"" (bare-rt-print #"foo"))
actual: java.lang.IllegalStateException: Can't dynamically bind non-dynamic var: clojure.core/print-initialized
at clojure.lang.Var.pushThreadBindings (Var.java:339)
clojure.core$push_thread_bindings.invoke (core.clj:1656)
clojure.test_clojure.rt$bare_rt_print$fn__14891.invoke (rt.clj:46)
clojure.test_clojure.rt$bare_rt_print.invoke (rt.clj:45)
clojure.test_clojure.rt/fn (rt.clj:53)
clojure.test$test_var$fn__1762.invoke (test.clj:693)
clojure.test$test_var.invoke (test.clj:693)
clojure.test$test_all_vars$fn_1766$fn_1773.invoke (test.clj:709)
clojure.test$default_fixture.invoke (test.clj:663)
clojure.test$test_all_vars$fn__1766.invoke (test.clj:709)
clojure.test$default_fixture.invoke (test.clj:663)
clojure.test$test_all_vars.invoke (test.clj:705)
clojure.test$test_ns.invoke (test.clj:728)
clojure.core$map$fn__2231.invoke (core.clj:2371)
clojure.lang.LazySeq.sval (LazySeq.java:42)
clojure.lang.LazySeq.seq (LazySeq.java:60)
clojure.lang.ChunkedCons.chunkedNext (ChunkedCons.java:59)
clojure.core$chunk_next.invoke (core.clj:643)
clojure.core$reException in thread "main" java.lang.IllegalStateException: Pop without matching push
at clojure.lang.Var.popThreadBindings(Var.java:350)
at clojure.core$pop_thread_bindings.invoke(core.clj:1658)
at clojure.main$script_opt.invoke(main.clj:338)
at clojure.main$main.doInvoke(main.clj:426)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.lang.Var.invoke(Var.java:401)
at clojure.lang.AFn.applyToHelper(AFn.java:161)
at clojure.lang.Var.applyTo(Var.java:518)
at clojure.main.main(main.java:37)
duce1.invoke (core.clj:878)
clojure.core$reduce1.invoke (core.clj:870)
clojure.core$merge_with.doInvoke (core.clj:2588)
clojure.lang.RestFn.applyTo (RestFn.java:139)
clojure.core$apply.invoke (core.clj:602)
clojure.test$run_tests.doInvoke (test.clj:743)
clojure.lang.RestFn.applyTo (RestFn.java:137)
clojure.core$apply.invoke (core.clj:600)
clojure.test_clojure$eval19718.invoke (run_tests.clj:58)
clojure.lang.Compiler.eval (Compiler.java:6328)
clojure.lang.Compiler.load (Compiler.java:6765)
clojure.lang.Compiler.loadFile (Compiler.java:6726)
clojure.main$load_script.invoke (main.clj:282)
clojure.main$script_opt.invoke (main.clj:342)
clojure.main$main.doInvoke (main.clj:426)
clojure.lang.RestFn.invoke (RestFn.java:408)
clojure.lang.Var.invoke (Var.java:401)
clojure.lang.AFn.applyToHelper (AFn.java:161)
clojure.lang.Var.applyTo (Var.java:518)
clojure.main.main (main.java:37)}}

[CLJ-774] Message-bearing assert

Fri, 29 Apr 2011 10:34:36 -0500

assert should take a String as a second argument. The string is printed when the assert fails.

This is lower hanging fruit than CLJ-415 but much better than the assert we currently have.

In the future, the second argument might be an expression that gets evaluated, but for now, it shouldn't be.

[CLJ-773] macros that are expanded away still have their vars referenced in the emitted byte code

Fri, 9 Dec 2011 10:01:00 -0600

if you have a macro like:

(defmacro f [a b] a)

and compile a function like:

(fn [x] (f x (/ 1 0)))

the macro is expand before compilation into:

(fn [x] x) ;; no reference to f

but the emitted byte code still holds the var for the macro 'f' in a static field.

[CLJ-772] bit ops to have primitive semantics by default, no conditionals, direct mapping to JVM primitive ops

Fri, 6 May 2011 08:49:10 -0500

Per Rich's comment on ~~CLJ-767~~.

[CLJ-769] partition-by holds references to head groups longer than necessary

Tue, 21 Jun 2011 14:06:41 -0500

partition-by continues to hold references to items of the input sequence where it should not anymore. That is after (rest s) there are still references held to the head group of the partition-by output sequence.

[CLJ-768] cl-format bug in ~f formatting

Fri, 15 Jun 2012 11:09:26 -0500

Carlos Ungil reports a bug in cl-format as follows (http://groups.google.com/group/clojure/browse_thread/thread/bb235ff4464aed78#):

Hello,

I don't know if there is a better way to file bug reports (if there is one,
it's not easy to find).

(use 'clojure.pprint)

(let [x 111.11111]
(doseq [fmt ["~3f~%" "~4f~%" "~5f~%" "~6f~%"]]
(cl-format true fmt x)))

;; 111.11111
;; 111.11111
;; 111.1
;; 111.11

There is clearly a problem in the first two cases, too many digits are being
printed.

For reference, this is what common lisp does:

(let ((x 111.11111))
(loop for fmt in '("_3f%" "_4f%" "_5f%" "_6f%")
do (format t fmt x)))

;; 111.
;; 111.
;; 111.1
;; 111.11

Cheers,

Carlos

[CLJ-765] Enhance clojure.java.shell/sh to accept more input types

Fri, 6 May 2011 08:49:09 -0500

Currently clojure.java.shell/sh will only accept bytes or Strings as inputs to the subprocess's stdin.

Attached patch replaces code specific to byte[] and String with a call to clojure.java.io/copy, thus additionally accepting InputStreams, Readers, and Files as input.

[CLJ-763] Do not use hash-map constructor in destructuring to avoid multiple key check.

Fri, 18 May 2012 20:37:21 -0500

What I did:

(defn number-to-string
  [& {fmt :format locale :locale :or {locale (Locale/getDefault)}}]
  (fn [v]
    (String/format locale fmt (to-array [v]))))

(defn double-to-string
  [& options]
  (apply number-to-string :format "%f" options))

(def us-number (double-to-string :locale Locale/US))
(def legacy-number (double-to-string :format "% 3.2f"))

(us-number 3.14159)
(legacy-number 3.14159)

What I expected:

"3.14159"
"  3,14"

What I got:

java.lang.IllegalArgumentException: Duplicate key: :format

Using into or a combination of reduce and assoc instead of hash-map would allow this without breaking things.

If this is a desired modification, I can provide a patch. (CA is filed.)

[CLJ-759] 1.3 alpha 6 seems to hold on to head in a case when 1.2 does not

Tue, 14 Feb 2012 01:06:21 -0600

File names here refer to attached files. Instead of attaching a large input file, I attach a small program that can be run to generate a large input file. To generate it, edit make-input-file.sh to point to a Clojure 1.2 JAR. Also edit run.sh to point to a Clojure 1.2 and 1.3 alpha 6 JAR. Do the following one time to create a ~ 125 Mbyte file long-input.txt:

./make-input-file.sh

With the JVMs I tested, I got these results, where the first argument is 1.2 or 1.3 for the Clojure version, and the second argument is the number of Mbytes to use for the max heap size of the JVM (i.e. the numeric value in the -Xmx<num>m argument in the java command line):

./run.sh 1.2 384 # failed with OutOfMemoryError 5/5 times tried
./run.sh 1.2 416 # succeeded 5/5 times tried

./run.sh 1.3 960 # failed 5/5 times tried
./run.sh 1.3 1048 # succeeded 5/5 or 4/5 times tried, for Mac OS X or Linux, respectively

I believe the issue is that with 1.3 alpha 6, the JVM is holding on to the head of the sequence called 'lines' for the duration of the execution of the function fasta-dna-str-with-desc-beginning, whereas 1.2 is losing the head after getting past the first when-let, and thus using significantly less memory.

[CLJ-757] Empty transient maps/sets return wrong value for .contains

Sat, 18 Aug 2012 07:50:41 -0500

As explained in http://groups.google.com/group/clojure/browse_thread/thread/496ffc7fb9058699/6e9d8152b6fd6365?show_docid=6e9d8152b6fd6365, (.contains (transient #{}) :some-key) returns true instead of false. (contains? #{} :some-key) works properly, but the plain .contains method does not.

The issue is in TransientHashMap.doValAt(key, notFound), and the attached patch is a simple fix with test.

[CLJ-755] automate distribution zip

Fri, 29 Jul 2011 10:08:40 -0500

In the move to maven, we lost the old ant automation for creating a release zip. In order to release 1.3.0-alpha6, I am using the following ant XML I hacked together:

<target name="dist">
    <property name="clojure.version.label" value="clojure-1.3.0-alpha6"/>
    <property name="distdir" value="dist/${clojure.version.label}"/>
    <mkdir dir="${distdir}"/>
    <copy todir="${distdir}" includeEmptyDirs="false">
      <fileset dir="${basedir}">
        <include name="*.xml"/>
        <include name="**/*.html"/>
        <include name="**/*.txt"/>
        <include name="**/*.markdown"/>
        <include name="**/*.clj"/>
        <include name="**/*.java"/>
      </fileset>
    </copy>
    <copy file="clojure.jar" todir="${distdir}"/>
    <zip basedir="dist" destfile="clojure-${clojure.version.label}.zip"/>
  </target>

What I need is something like this, but properly parameterized and integrated into the maven build, so I can grab it from hudson or central or somewhere after a release build.

[CLJ-754] 1.2.1 release

Sun, 20 Mar 2011 08:46:36 -0500

See http://dev.clojure.org/display/design/Release+1.2.1 and http://groups.google.com/group/clojure-dev/browse_thread/thread/f1b1fbfd2a6c1a9f

[CLJ-753] clojure.string/replace-first returns nil with replacement fn when regex doesn't match

Fri, 1 Mar 2013 12:47:01 -0600

Originally reported by Takahiro Hozumi

With a function as the "replacement" argument, clojure.string/replace-first returns nil if there is no match, instead of returning the original string unchanged.

user=> (use 'clojure.string)
nil
user=> (replace-first "abcdef" "ghi" "jkl")
"abcdef"
user=> (replace-first "abcdef" #"ghi" "jkl")
"abcdef"
user=> (replace-first "abcdef" #"ghi" (fn [a] "jkl"))
nil

[CLJ-752] Remove earmuff == dynamic support

Fri, 1 Mar 2013 12:47:01 -0600

As a compatibility bridge, when dynamic var support was first added, *earmuffed* vars were automagically considered dynamic. Users were promised this bridge would be removed before release. Let's get this change in so people can start dealing with it.

[CLJ-751] cl-format: ~( thows an exception with an empty string

Fri, 1 Mar 2013 12:47:00 -0600

cl-format: ~( thows an exception with an empty string

[CLJ-749] reference a definterface in file that declares it

Fri, 11 Mar 2011 10:21:20 -0600

~~CLJ-737~~ introduced a regression: you can no longer refer to a definterface (e.g. as a type hint) later in the file that declares it. This is caused by the use of Java reflection, where the original code path used ASM reflection.

The patch will keep most of the enhancement of ~~CLJ-737~~ (arrays of primitives), but will not support arrays of classes. (This did not trivially work, but can be made to work as a separate enhancement if anybody strongly needs it.)

[CLJ-748] fast path equal case for diff

Wed, 2 Mar 2011 06:39:56 -0600

For the use case of clojure.data/diff in comparing test results and expectations, it would be nice to do minimal work if the objects are equal. A simple check is low-hanging fruit.

[CLJ-747] stack overflow diffing large objects

Wed, 2 Mar 2011 06:39:57 -0600

e.g.

(clojure.data/diff (range 50000) (range 50000))))

[CLJ-745] gen-class should allow exposes-methods to expose protected final methods

Sat, 18 Aug 2012 07:50:41 -0500

Currently, there is no way in Clojure to call a protected final method of a superclass. While this may be an acceptable limitation for proxy, gen-class should provide that ability. Otherwise, one is now forced to create a dummy subclass in Java for the sole purpose of widening the visibility of such methods.

My patch makes it so that protected final methods may be exposed via the :exposes-methods mechanism. It is still impossible to override them.

[CLJ-742] Error message for invalid map literals is not helpful

Fri, 25 Feb 2011 15:06:26 -0600

Literal maps with an odd number of forms give an IndexOutOfBounds exception, which is unhelpful and misleading in determining the source of the error. They should instead return a more specific error, something like "map literal must contain an even number of forms".

[CLJ-741] Stop ISeq from inheriting Sequential

Fri, 11 Mar 2011 10:21:10 -0600

Currently, ISeq extends Sequential, which is what collections like vector use to determine equality partition membership. This prevents anything that implements ISeq from being exclusively in the map or set equality partition.

"Care will be required in making sure all appropriate concrete derivees remain Sequential. It's a breaking change in that some derivees not in Clojure may be relying on the derivation from ISeq"

http://groups.google.com/group/clojure-dev/browse_thread/thread/c58ec42d78209ee0

[CLJ-739] version.properties file is not closed

Fri, 25 Feb 2011 15:06:28 -0600

Originally reported by Olek at https://groups.google.com/d/topic/clojure/jhdSyljImuU/discussion

When loading core.clj, the stream opened on the version.properties file is never closed. This can cause problems in some environments such as JEE.

[CLJ-738] <= is incorrect when args include Double/NaN

Fri, 1 Mar 2013 12:47:10 -0600

user> (<= 10 Double/NaN 1)
true

(on both 1.2 and 1.3 alpha 5).

[CLJ-737] definterface/gen-interface do not support array parameter and return types

Fri, 25 Feb 2011 15:25:30 -0600

As describe in this clojure-dev post, gen-interface and definterface do not properly support array type hints.

Ultimately, this is because gen-class and gen-interface use two different code paths to do essentially the same thing. Boiled down, gen-class converts hints using (Type/getType (the-class c)), whereas gen-interface uses asm-type, which uses similar, but different, logic than the-class.

In my patch, I change asm-type to match use the-class. I also add entries to the prim->class map to support primitive arrays.

[CLJ-736] Docstring of defrecord (and =) does not correctly describe equality behavior for records.

Fri, 1 Mar 2013 12:47:03 -0600

http://groups.google.com/group/clojure/browse_frm/thread/eba691b38c45196b#

The docstring of defrecord says it "will define type-and-
value-based equality and hashCode". In reality, record types are included in = but not .equals (or hashCode), and so records of different types can collide as map keys.

Along the same lines, the docstring of = says "same as Java x.equals, except it ... compares numbers and collections in a type-independent manner". To me, this seems to imply the opposite of what actually happens with records.

FWIW I think it would be more clear if the behavior for = and .equals were the same in this respect, but in any case the implemented behavior should be properly documented.

[CLJ-734] starting scope of let bindings seems incorrect from jdi perspective

Fri, 11 Mar 2011 10:21:22 -0600

It appears like the clojure compiler doesn't get the starting scope of let bindings right from the java debug interface perspective.

The compiler sets the starting scope of a local to the let/loop body, rather than to immediately after the local is bound. So when you are stepping through a let statement in a debugger, you can't eval the already defined bindings until you get to the let body.

Because it is a compiler problem, you see the symptoms with any jdi based debugger, (I've confirmed this on both jdb and cdt.)

The fix is pretty straightforward. Just gen.mark() a label after each binding is emitted and use that in the gen.visitLocalVariable() call instead of the loopLabel. I've attached a patch for clojure 1.2 branch. (If there is interest I'll create one for clojure master.)

Clojure JIRA

[CLJ-1168] Setting clojure.read.eval to unknown on JVM cmd line causes --eval option to fail

[CLJ-1163] Updates to changes.md for Clojure 1.5.0-RC15

[CLJ-1158] generative tests for read and edn/read

[CLJ-1150] Make some PersistentVector, SubVector internals public

[CLJ-1140] {:as x} destructuring with an empty list raises exception

[CLJ-1135] Add previous changelog items back to changes.md

[CLJ-1116] More REPL-friendly 'ns macro

[CLJ-1114] reify ignores :pre and :post

[CLJ-1111] Loops returning primtives are boxed even in return position

[CLJ-1110] let-> needs improvement

[CLJ-1109] Oracle Java 5 fails to run tests when building Clojure

[CLJ-1106] Broken equality for sets

[CLJ-1098] Extend CollFold and IKVReduce to nil

[CLJ-1092] New function re-quote-replacement has incorrect :added metadata

[CLJ-1091] update changes.md to include 1.5 changes

[CLJ-1085] clojure.main/repl unconditionally refers REPL utilities into *ns*

[CLJ-1084] (object-array [1]) is ~3x slower than (object-array (rseq [1]))

[CLJ-1071] ExceptionInfo does no abstraction

[CLJ-1070] PersistentQueue's hash function does not match its equality

[CLJ-1066] No dependency on jsr166y

[CLJ-1065] Allow duplicate set elements and map keys for all set and map constructors

[CLJ-1062] CLJ-940 breaks compilation of namespaces that don't have any public functions

[CLJ-1061] when-first double evaluation

[CLJ-1055] "be come" should be "become"

[CLJ-1052] assoc should throw exception if missing val for last key

[CLJ-1048] add test.generative to Clojure's tests

[CLJ-1041] reduce-kv on sorted maps should stop on seeing a Reduced value

[CLJ-1038] Docstring for deliver doesn't match behavior

[CLJ-1034] "Conflicting data-reader mapping" triggered when the same data_readers.clj is on the classpath twice

[CLJ-1032] seque leaks threads from the send-off pool

[CLJ-1031] Website documentation for evaluation has misleading information about "load"

[CLJ-1019] ns-resolve doc has a typo

[CLJ-1012] partial function should also accept 1 arg (just f)

[CLJ-1011] clojure.data/diff should cope with null and false values in maps

[CLJ-1009] make print-table org mode compatible

[CLJ-1000] Performance drop in PersistentHashMap.valAt(...) in v.1.4 -- Util.hasheq(...) ?

[CLJ-990] Implement clojure.core.reducers/mapcat and some initial reducers tests

[CLJ-989] clojure.org/downloads page, nightly builds link out of date

[CLJ-988] the locking in MultiFn.java (synchronized methods) can cause lots of contention in multithreaded programs

[CLJ-987] pprint doesn't flush the underlying stream

[CLJ-985] make jsr166 available at build time

[CLJ-981] clojure.set/rename-keys deletes keys when there's a collision

[CLJ-977] (int \a) returns a value, (long \a) throws an exception

[CLJ-975] inconsistent destructuring behaviour when using nested maps

[CLJ-973] doc for *data-readers* is wrong about the format for data_readers.clj

[CLJ-972] Document changes between Clojure 1.3 and 1.4

[CLJ-966] Add support for marker protocols

[CLJ-965] clojure.org/patches should have link to JIRA workflow wiki page added, and most content removed

[CLJ-964] test-clojure/rt.clj has undeclared dependency on clojure.set

[CLJ-963] Support pretty printing namespace declarations under code-dispatch

[CLJ-962] Vectors returned by subvec allow access at negative indices

[CLJ-961] with-redefs loses a Var's root binding if the Var is thread-bound

[CLJ-960] Capture :column metadata (needed for ClojureScript source maps)

[CLJ-954] TAP Support in clojure.test.tap Needs Updating

[CLJ-953] drop-while doc string wrong, nil instead of logical false

[CLJ-952] bigdec does not properly convert a clojure.lang.BigInt

[CLJ-948] It would be very useful to be able to annotate the constructors of classes created with gen-class

[CLJ-943] When load-lib fails, a namespace is still created

[CLJ-942] Calls to instance methods through the Reflector double unwrap exceptions

[CLJ-940] Passing a non-sequence to refer :only results in uninformative exception

[CLJ-936] Improve docs about argument destructuring at clojure.org

[CLJ-934] disj! throws exception when attempting to remove multiple items in one call

[CLJ-933] Compiler warning on clojure.test-clojure.require-scratch

[CLJ-932] contains? should throw exception on non-keyed collections

[CLJ-931] Syntactically broken clojure.test/are tests succeed

[CLJ-928] instant literal for Date and Timestamp should print in UTC

[CLJ-927] default tagged literal reader

[CLJ-925] rand-nth throws on empty list

[CLJ-924] Error reporting of invalid digit in unicode character literal

[CLJ-923] Reading ratios prefixed by + is not working

[CLJ-921] Ant 1.8 gives warning about 'includeantruntime' when building Clojure

[CLJ-920] Adds support for FreeDesktop's xdg-open in clojure.java.browse/browse-url.

[CLJ-917] clojure.core/definterface is not included in the API docs

[CLJ-916] into loses metadata

[CLJ-914] Add support for UUID literals using tagged literal capability.

[CLJ-910] [Patch] Allow for type-hinting the method receiver in memfn

[CLJ-909] Make LineNumberingPushbackReader's buffer size configurable

[CLJ-905] clojure.string/replace-first treats \ and $ specially when match is a string, unlike clojure.string/replace

[CLJ-904] Document *read-eval* in read, read-string

[CLJ-1085] clojure.main/repl unconditionally refers REPL utilities into ns

[CLJ-973] doc for data-readers is wrong about the format for data_readers.clj

[CLJ-904] Document read-eval in read, read-string

[CLJ-846] Javadoc does not detect 1.7 when setting core-java-api

[CLJ-822] Reporting methods in clojure.test//-report should be marked dynamic