All inactive Clojure issues (Clojure JIRA)

[CLJ-1203] Fallback to hash-based comparison for non-Comparables in Util.compare()

Mon, 29 Apr 2013 02:30:08 -0500

I oftentimes use sorted collections, and my comparator functions usually look like that:

(fn [a b]
  (let [x (compare-according-to-my-use-case a b)]
    (if (zero? x)
       (compare a b)
       x)))

That is, I define the sorting order depending on the requirements of my use-case, and if that doesn't suffice to make a distinction, I simply fall back to the standard `compare` function in order to get a stable ordering anyhow. I think that's a widely used idiom, e.g., also used in "Clojure Programming" (for example page 109).

The problem with this approach is that several data structures don't implement Comparable, and thus aren't applicable to `compare` (you'll get a ClassCastException). Examples are maps, records, deftypes, and sequences.

The patch I'm going to attach extends `Util.compare()` with a fallback clause that performs a `hasheq()`-based comparison. This results in a meaningless but at least stable sorting order which suffices for use-cases like the one shown above.

[CLJ-1196] eval of defrecord instance with no fields produces {}, not itself

Wed, 10 Apr 2013 11:42:33 -0500

user> (defrecord Foo [])
user.Foo
user> (Foo.)
#user.Foo{}
user> (eval (Foo.))
{}

user> (defrecord Foo [a b])
user.Foo
user> (eval (Foo. 1 2))
#user.Foo{:a 1, :b 2}

As you can see, evaluating the record with no fields loses the type information. This came up in code that uses records to describe argument schema information for functions in a macro, with no direct use of 'eval'. It is unexpected because of the inconsistency between empty and non-empty defrecords, and because the Clojure docs say 'Any object other than those discussed above will evaluate to itself.'

http://clojure.org/evaluation

I'm happy to elaborate on the use case if there are questions.

[CLJ-1194] Typo in core.reducers

Tue, 9 Apr 2013 04:49:58 -0500

As far as I can say, there is a typo in core.reducers (and therefore core.reducers/monoid is unusable in 1.5.1):

https://github.com/clojure/clojure/blob/master/src/clj/clojure/core/reducers.clj#L321

(fn m <-- this
    ([] (ctor))
    ([a b] (op a b))))

Should I submit a patch to fix this?

[CLJ-1188] Public Java API

Fri, 12 Apr 2013 13:51:46 -0500

Problem: Java consumers need an API into Clojure that does not drag in a ton of concrete implementation detail.

Solution: Very small API class that allows looking up Vars (returning IFn), and reading data (as edn). Uses Clojure logic where possible, e.g. Var.intern.

Current patch: ~~CLJ-1188~~-via-var-intern.patch

Also considered:

wrapper class (inconvenient for users, wrappers anathema in Clojure)
common superinterface for IFn and Deref (unnecessary, might bloat vtable)

[CLJ-1179] distinct? does not accept zero arguments

Fri, 12 Apr 2013 09:12:55 -0500

distinct? cannot be invoked with zero arguments. When using the pattern (apply distinct? x), this is bothersome as you have to check whether x is empty or not. It is also logical that distinct? should return true if no arguments are given, since there are no duplicates.

What (small set of) steps will reproduce the problem?

user=> (apply distinct? [])
ArityException Wrong number of args (0) passed to: core$distinct-QMARK-  clojure.lang.AFn.throwArity (AFn.java:437)

What is the expected output? What do you see instead?

I would expect distinct? to return true whenever given zero arguments.

What version are you using?

This was tested under Clojure 1.4 and Clojure 1.5.

[CLJ-1178] Requiring the same ns doesn't throw an exception

Fri, 29 Mar 2013 05:57:12 -0500

The compiler will happily allow requiring the same ns twice. I can't see any reason you'd intentionally do this.

(ns program
  (:require [program.a :as a]
            [program.a :as b])

This caused some confusion for a while as to why b wasn't producing the expected functionality. Just a simple mistake that I think can be caught at compile time.

[CLJ-1174] Website doc link for 1.4 api docs returns a 404

Tue, 5 Mar 2013 20:29:46 -0600

The API docs for Clojure 1.4 (http://clojure.github.com/clojure/branch-clojure-1.4.0/index.html), linked to from http://clojure.github.com/clojure/, returns a 404.

I logged it under this category because I can't see anywhere else to log bugs about clojure.org.

[CLJ-1173] One-arg protocol functions whose name begins in a dash generates a call to a wrong field in the emitted code

Fri, 17 May 2013 13:36:40 -0500

(defprotocol P (-foo [this]))

This code generates a reflective call to a non-existing foo field instead of the correct -foo method.

I was told by Christophe Grand that changing the line 557 in core_deftype.clj from:

(. ~(with-meta target {:tag on-interface}) ~(or on-method method) ~@(rest gargs))

(. ~(with-meta target {:tag on-interface}) (~(or on-method method) ~@(rest gargs)))

is a quick fix. However I don't know too much about the compilation specifics of . to judge whether this is the correct fix.

Issue reproduction:

Clojure
user=> (set! *warn-on-reflection* true)
true
user=> (defprotocol P (-foo [this]))
P
Reflection warning, REPL:4 - reference to field foo can't be resolved.

[CLJ-1170] conj-ing x on equal values should produce equal results

Fri, 1 Mar 2013 10:04:40 -0600

I've recently have run into a WHAT behavior here is an example:

```clojure
(def head 1)
(def tail [2 3])

(= tail (rest (cons head tail))) ; true

;; Types don't really match but close enough I guess
(type tail) ; clojure.lang.PersistentVector
(vector? tail) ; true
(type (rest (cons head tail))) ; clojure.lang.PersistentVector$ChunkedSeq
(vector? (rest (cons head tail))) ; false

;; Bet then it get's ugly (I would expect them to be equal)
(= (conj tail :x) (conj (rest (cons head tail)) :x)) ; false

;; Because
(conj tail :x) ; [2 3 :x]
(conj (rest (cons head tail)) :x) ;(:x 2 3)
```

This brings me to a pretty surprising behavior, which is conj-ing
equal values produce non-equal results:

```clojure
(= '(2 3) [2 3]) ; true
(= (conj '(2 3) 1) (conj [2 3] 1))
```

I think conj should either produce equal results or list and vectors with
same elements should not be equal. That would also resolve a previous
problem, although intuitively I would expect `(rest (cons x y))` to
return `y` back.

[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-1166] Range function accumulates minor errors when called on floating-point numbers

Fri, 29 Mar 2013 17:10:49 -0500

Due to range's incremental computation minor errors introduced by floating point arithmetic accumulate, becoming more noticeable in long ranges and causing unexpected behaviour.

Compare the output of the following:

=> (range 0.0 10.0 0.1)
(0.0 0.1 0.2 0.30000000000000004 0.4 0.5 0.6 0.7 0.7999999999999999 0.8999999999999999 0.9999999999999999 1.0999999999999999 1.2 1.3 1.4000000000000001 1.5000000000000002 1.6000000000000003 1.7000000000000004 1.8000000000000005 1.9000000000000006 2.0000000000000004 2.1000000000000005 2.2000000000000006 2.3000000000000007 2.400000000000001 2.500000000000001 2.600000000000001 2.700000000000001 2.800000000000001 2.9000000000000012 3.0000000000000013 3.1000000000000014 3.2000000000000015 3.3000000000000016 3.4000000000000017 3.5000000000000018 3.600000000000002 3.700000000000002 3.800000000000002 3.900000000000002 4.000000000000002 4.100000000000001 4.200000000000001 4.300000000000001 4.4 4.5 4.6 4.699999999999999 4.799999999999999 4.899999999999999 4.999999999999998 5.099999999999998 5.1999999999999975 5.299999999999997 5.399999999999997 5.4999999999999964 5.599999999999996 5.699999999999996 5.799999999999995 5.899999999999995 5.999999999999995 6.099999999999994 6.199999999999994 6.299999999999994 6.399999999999993 6.499999999999993 6.5999999999999925 6.699999999999992 6.799999999999992 6.8999999999999915 6.999999999999991 7.099999999999991 7.19999999999999 7.29999999999999 7.39999999999999 7.499999999999989 7.599999999999989 7.699999999999989 7.799999999999988 7.899999999999988 7.999999999999988 8.099999999999987 8.199999999999987 8.299999999999986 8.399999999999986 8.499999999999986 8.599999999999985 8.699999999999985 8.799999999999985 8.899999999999984 8.999999999999984 9.099999999999984 9.199999999999983 9.299999999999983 9.399999999999983 9.499999999999982 9.599999999999982 9.699999999999982 9.799999999999981 9.89999999999998 9.99999999999998)

=> (defn range' [start end step] (map #(+ start (* % step)) (range 0 (/ (- end start) step) 1)))
=> (range' 0.0 10.0 0.1)
(0.0 0.1 0.2 0.30000000000000004 0.4 0.5 0.6000000000000001 0.7000000000000001 0.8 0.9 1.0 1.1 1.2000000000000002 1.3 1.4000000000000001 1.5 1.6 1.7000000000000002 1.8 1.9000000000000001 2.0 2.1 2.2 2.3000000000000003 2.4000000000000004 2.5 2.6 2.7 2.8000000000000003 2.9000000000000004 3.0 3.1 3.2 3.3000000000000003 3.4000000000000004 3.5 3.6 3.7 3.8000000000000003 3.9000000000000004 4.0 4.1000000000000005 4.2 4.3 4.4 4.5 4.6000000000000005 4.7 4.800000000000001 4.9 5.0 5.1000000000000005 5.2 5.300000000000001 5.4 5.5 5.6000000000000005 5.7 5.800000000000001 5.9 6.0 6.1000000000000005 6.2 6.300000000000001 6.4 6.5 6.6000000000000005 6.7 6.800000000000001 6.9 7.0 7.1000000000000005 7.2 7.300000000000001 7.4 7.5 7.6000000000000005 7.7 7.800000000000001 7.9 8.0 8.1 8.200000000000001 8.3 8.4 8.5 8.6 8.700000000000001 8.8 8.9 9.0 9.1 9.200000000000001 9.3 9.4 9.5 9.600000000000001 9.700000000000001 9.8 9.9)

[CLJ-1164] typos in instant.clj

Fri, 24 May 2013 07:55:08 -0500

There are a few typographical mistakes in instant.clj.

[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-1156] clojure.walk/stringifiy-keys does not stringify non-keyword keys

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

The doc says "Recursively transforms all map keys from keywords to strings." however only those keys that pass keyword? get transformed to string. This leaves other keys such as java.Long as-is.

A simple fix would be

(defn stringify-keys*
"Recursively transforms all map keys from keywords to strings."
[m]
(let [f (fn [[k v]] (if (keyword? k) [(name k) v] [(str k) v]))]
;; only apply to maps
(postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))

[CLJ-1155] Suppress tracebacks from clojure.core

Fri, 29 Mar 2013 06:06:12 -0500

It would be really nice if we could hide the Java traceback from the compiler when it's not relevant. When there's no Java interop, it's not useful. I can't see any case where we want the tracebacks from the compiler referencing clojure.core.

Here's how a syntax error traceback looks at the moment on trunk:

$ more dodgy-map.clj
(defn dodgy-map []
  {:1 :2 :3})
$ java -cp target/clojure-1.5.0-master-SNAPSHOT.jar clojure.main dodgy-map.clj
Exception in thread "main" java.lang.RuntimeException: Map literal must contain an even number of forms, compiling:(/home/wilfred/src/clojure/dodgy-map.clj:2:13)
	at clojure.lang.Compiler.load(Compiler.java:7070)
	at clojure.lang.Compiler.loadFile(Compiler.java:7020)
	at clojure.main$load_script.invoke(main.clj:286)
	at clojure.main$script_opt.invoke(main.clj:348)
	at clojure.main$main$fn__6682.invoke(main.clj:432)
	at clojure.main$main.doInvoke(main.clj:429)
	at clojure.lang.RestFn.invoke(RestFn.java:408)
	at clojure.lang.Var.invoke(Var.java:415)
	at clojure.lang.AFn.applyToHelper(AFn.java:161)
	at clojure.lang.Var.applyTo(Var.java:532)
	at clojure.main.main(main.java:37)
Caused by: java.lang.RuntimeException: Map literal must contain an even number of forms
	at clojure.lang.Util.runtimeException(Util.java:219)
	at clojure.lang.LispReader$MapReader.invoke(LispReader.java:1090)
	at clojure.lang.LispReader.readDelimitedList(LispReader.java:1145)
	at clojure.lang.LispReader$ListReader.invoke(LispReader.java:979)
	at clojure.lang.LispReader.read(LispReader.java:182)
	at clojure.lang.Compiler.load(Compiler.java:7058)
	... 10 more

With my patch, this is simplified to:

$ java -cp target/clojure-1.5.0-master-SNAPSHOT.jar clojure.main dodgy-map.clj
java.lang.RuntimeException: Map literal must contain an even number of forms, compiling:(/home/wilfred/src/clojure/dodgy-map.clj:2:13)

Another example: here's how name errors appear on trunk:

$ more i-dont-exist.clj
(defn no-such-variable []
  i-dont-exist)
$ java -cp target/clojure-1.5.0-master-SNAPSHOT.jar clojure.main i-dont-exist.clj
Exception in thread "main" java.lang.RuntimeException: Unable to resolve symbol: i-dont-exist in this context, compiling:(/home/wilfred/src/clojure/i-dont-exist.clj:1:1)
	at clojure.lang.Compiler.analyze(Compiler.java:6380)
	at clojure.lang.Compiler.analyze(Compiler.java:6322)
	at clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5708)
	at clojure.lang.Compiler$FnMethod.parse(Compiler.java:5139)
	at clojure.lang.Compiler$FnExpr.parse(Compiler.java:3751)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6558)
	at clojure.lang.Compiler.analyze(Compiler.java:6361)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6548)
	at clojure.lang.Compiler.analyze(Compiler.java:6361)
	at clojure.lang.Compiler.access$100(Compiler.java:37)
	at clojure.lang.Compiler$DefExpr$Parser.parse(Compiler.java:529)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6560)
	at clojure.lang.Compiler.analyze(Compiler.java:6361)
	at clojure.lang.Compiler.analyze(Compiler.java:6322)
	at clojure.lang.Compiler.eval(Compiler.java:6623)
	at clojure.lang.Compiler.load(Compiler.java:7063)
	at clojure.lang.Compiler.loadFile(Compiler.java:7020)
	at clojure.main$load_script.invoke(main.clj:286)
	at clojure.main$script_opt.invoke(main.clj:348)
	at clojure.main$main$fn__6682.invoke(main.clj:432)
	at clojure.main$main.doInvoke(main.clj:429)
	at clojure.lang.RestFn.invoke(RestFn.java:408)
	at clojure.lang.Var.invoke(Var.java:415)
	at clojure.lang.AFn.applyToHelper(AFn.java:161)
	at clojure.lang.Var.applyTo(Var.java:532)
	at clojure.main.main(main.java:37)
Caused by: java.lang.RuntimeException: Unable to resolve symbol: i-dont-exist in this context
	at clojure.lang.Util.runtimeException(Util.java:219)
	at clojure.lang.Compiler.resolveIn(Compiler.java:6874)
	at clojure.lang.Compiler.resolve(Compiler.java:6818)
	at clojure.lang.Compiler.analyzeSymbol(Compiler.java:6779)
	at clojure.lang.Compiler.analyze(Compiler.java:6343)
	... 25 more

With patch:

$ java -cp target/clojure-1.5.0-master-SNAPSHOT.jar clojure.main i-dont-exist.clj
java.lang.RuntimeException: Unable to resolve symbol: i-dont-exist in this context, compiling:(/home/wilfred/src/clojure/i-dont-exist.clj:1:1)

I'm not familiar with the compiler internals, but I've attached a tentative patch. Undoubtedly it isn't perfect. For one, it would be nicer to say 'Syntax error' rather than 'java.lang.RuntimeException'. All the tests pass with this change.

Relevant mailing list discussion: https://groups.google.com/forum/?fromgroups=#!searchin/clojure/wilfred/clojure/M5NlEW7HJ_c/joUY6mo6Rd8J

Please let me know what you think. This would make my life easier when developing.

[CLJ-1153] Change read-eval default value to false

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

Discussion on the security implications of read-eval defaulting to true here: https://groups.google.com/forum/?fromgroups=#!topic/clojure/qUk-bM0JSGc

I'm not sure whether the unit test that needs read-eval true in order to pass is a sign of lots of other code that would break if read-eval defaulted to false.

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

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

This should help with RRBT-PV interop.

[CLJ-1145] thread-last can't accept 0 or 1 forms, thread-first can't accept 0 forms

Sun, 13 Jan 2013 09:40:39 -0600

At times, as the artifact of repl experimentation or a refactoring in progress, one wants to eval a threaded form with 1 or (less likely) 0 arguments.

(-> 42) ; fine
(->> 42) ; throws "ArityException Wrong number of args (1) passed to: core$-GT".

(->) ; throws "ArityException Wrong number of args (0) passed to: core$" (sic)
(->>) ; throws "ArityException Wrong number of args (0) passed to: core$-GT".

Apologies for the text rendering (how to cite code?).

[CLJ-1143] Minor correction to doc string of ns macro

Fri, 24 May 2013 07:55:08 -0500

The doc string of ns says "If :refer-clojure is not used, a default (refer 'clojure) is used." 'clojure should be replaced with 'clojure.core

Clojure group thread: https://groups.google.com/forum/?fromgroups=#!topic/clojure/rDjZodxOMh8

[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-1139] Compiler exception while compiling swank/commands/basic.clj

Sat, 9 Feb 2013 02:20:30 -0600

Current Behavior:

When attempting to start a swank server, the clojure compiler throws a CompilerException, and the process terminates.

Expected Behavior:

A swank server is successfully started.

Steps to reproduce (terminal session attached):

1. lein new tmp
2. Edit the project.clj to require clojure version 1.5.0-RC1
4. cd tmp
3. lein swank

[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-1129] Invalid ns macro can yield a difficult to trace exception

Wed, 19 Dec 2012 01:09:27 -0600

I inadvertently stripped off the namespace part of my ns macro, so that it was (ns (:use .... Clearly a user error, but an easy one. However, the result (from the REPL or the AOT compiler) was not ideal:

Exception in thread "main" java.lang.ClassCastException: clojure.lang.PersistentList cannot be cast to clojure.lang.Named
	at clojure.core$name.invoke(core.clj:1489)
	at clojure.core$root_resource.invoke(core.clj:5210)
	at clojure.core$load_one.invoke(core.clj:5227)
	at clojure.core$compile$fn__4895.invoke(core.clj:5426)
	at clojure.core$compile.invoke(core.clj:5425)
	at clojuresque.tasks.compile$main$fn__64.invoke(compile.clj:23)
	at clojuresque.cli$with_command_line_STAR_.invoke(cli.clj:92)
	at clojuresque.tasks.compile$main.doInvoke(compile.clj:6)
	at clojure.lang.RestFn.applyTo(RestFn.java:137)
	at clojure.core$apply.invoke(core.clj:601)
	at clojure.lang.Var.invoke(Var.java:419)
	at clojuresque.Driver.main(Driver.java:39)

The problem here is that there is no indication of what file was being loaded and compiled at the time of the error. Since I was in the middle of refactoring a big swath of code, I had some work to do to track down which file I had mangled.

I would like to see a little more logging to the System/err to identify what resource file was being read and compiled by the compiler at the time of the exception.

[CLJ-1123] UNIX/Windows line endings - clojure.pprint tests cause failure in Windows build

Mon, 10 Dec 2012 11:45:23 -0600

I ran a test build of the latest Clojure 1.5 master (372f03e) on Windows and found a number of failures in the "clojure.test-clojure.pprint" tests. All of these seem to be caused by incorrect assumptions about line endings. Example:

[java] {:clojure.test/vars (ns-macro-test),
[java] :thread/name "main",
[java] :pid 1528,
[java] :thread 1,
[java] :type :assert/fail,
[java] :level :warn,
[java] :test/actual
[java] (not
[java] (clojure.core/=
[java] "(ns slam.hound.stitch\r\n (:use [slam.hound.prettify :only [prettify]]))\r\n"
[java] "(ns slam.hound.stitch\n (:use [slam.hound.prettify :only [prettify]]))\n")),
[java] :test/expected
[java] (clojure.core/=
[java] (clojure.core/with-out-str
[java] (clojure.pprint/with-pprint-dispatch
[java] clojure.pprint/code-dispatch
[java] (clojure.pprint/pprint
[java] (clojure.core/read-string
[java] "(ns slam.hound.stitch\n (:use [slam.hound.prettify :only [prettify]]))"))))
[java] (clojure.core/str
[java] "(ns slam.hound.stitch\n (:use [slam.hound.prettify :only [prettify]]))"
[java] "\n")),
[java] :line 173,
[java] :tstamp 1355113319212,
[java] :file "test_pretty.clj"}

It isn't totally clear what the right behaviour should be: should pprint be producing platform specific line endings or not? Either way, the test should confirm the expected behaviour.

[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-1101] default-data-reader-fn should be set!-able in REPL

Fri, 24 May 2013 07:55:08 -0500

In ~~CLJ-927~~, Nicola Mometto pointed out that *default-data-reader-fn* should be set!-able. The fix needs to be added to clojure.main/with-bindings.

[CLJ-1099] better error message when passing non-seq to seq

Fri, 24 May 2013 07:55:08 -0500

Design discussion here.

This patch improves Clojure's error message for a single common error: passing a non-seq where a seq is neede. More importantly, it is intended as a prototype for other similar improvements in the future.

Error message before:

(cons 1 2)
=> IllegalArgumentException Don't know how to create ISeq from: java.lang.Long

Error message after:

user=> (cons 1 2)
ExceptionInfo Don't know how to create ISeq from: java.lang.Long
user=> (ex-data *e)
{:instance 2}

[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-1089] clojure.java.io/copy interprets read count of 0 as eos

Mon, 22 Oct 2012 16:57:16 -0500

According to the interface http://docs.oracle.com/javase/6/docs/api/java/io/InputStream.html#read()
InputStream.read() family of methods return -1 when the end of stream is reached.

do-copy methods currently use a test: (pos? size) to determine whether eos is reached. This mostly works, but the specification is pretty clear in that InputStream implementations are allowed to return reads of zero bytes before returning more bytes.

##EDIT changed title of ticket from "clojure.java.io/copy should test for -1 instead of 0 for end of stream"

[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-1075] deftype: compiler error on set! for mutable field

Mon, 3 Dec 2012 10:52:03 -0600

The following code demonstrates the error in a minimal example:

(defprotocol IBlob (do-sth [this, x]))

(deftype Blob [^{:volatile-mutable true} a]
  IBlob
  (do-sth [this, x] 
    (try (/ 1 x) 
      (catch Throwable t 
        (set! a (inc a))))
        (inc x)))

(deftype Blob2 [^{:volatile-mutable true} a]
  IBlob
  (do-sth [this, x] 
    (try (/ 1 x) 
      (catch Throwable t 
        (set! a (inc a))))))

Compiling Blob results in the following exception:

CompilerException java.lang.IllegalArgumentException: Cannot assign to non-mutable: a

Compiling Blob2 works as expected.

[CLJ-1072] Replace old metadata reader macro syntax

Fri, 24 May 2013 07:55:10 -0500

5 files still have old metadata reader syntax hash-caret instead of just caret:

src/clj/clojure/core.clj
src/clj/clojure/gvec.clj
src/clj/clojure/java/browse_ui.clj
src/clj/clojure/java/io.clj
src/clj/clojure/repl.clj

[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-1069] data.priority-map has no artifacts information in the README

Fri, 14 Sep 2012 15:41:31 -0500

data.priority-map README has no artifacts information and does not conform to the Contrib README standards in any way. Because clojure-dev is a closed group, I am filing it here

[CLJ-1068] algo.monads README has no artifacts information

Fri, 14 Sep 2012 15:39:10 -0500

algo.monads README has no artifacts information and does not conform to the Contrib README standards in any way. Because clojure-dev is a closed group, I am filing it here

[CLJ-1067] Fix error message inconsistencies in Symbol and Keyword

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

1. There are some ugly and unnecessary – but harmless – inconsistencies between Symbol and Keyword:

(.run 'foo);    => ArityException Wrong number of args (0) passed to: Symbol  clojure.lang.AFn.throwArity (AFn.java:437)
(.run :foo);    => UnsupportedOperationException   clojure.lang.Keyword.run (Keyword.java:97)
(.call 'foo);   => ArityException Wrong number of args (0) passed to: Symbol  clojure.lang.AFn.throwArity (AFn.java:437)
(.call :foo);   => IllegalArgumentException Wrong number of args passed to keyword: :foo  clojure.lang.Keyword.throwArity (Keyword.java:88)
(.invoke 'foo); => ArityException Wrong number of args (0) passed to: Symbol  clojure.lang.AFn.throwArity (AFn.java:437)
(.invoke :foo); => IllegalArgumentException Wrong number of args passed to keyword: :foo  clojure.lang.Keyword.throwArity (Keyword.java:88)

2. Keyword.java contains a lot of code that has already been factored out to AFn.java.

I propose that Keyword is modified to extend AFn to resolve the above issues.

[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-1064] Broken update-in for empty keys vector

Sat, 8 Sep 2012 10:15:38 -0500

Using update-in with an empty keys vector produces unexpected results:
(update-in {:a 10 :b 20} [] dissoc :a)
⇒ {nil nil, :a 10, :b 20}
(update-in {:a 10 :b 20} [] assoc :c 99)
⇒ {nil {:c 99}, :a 10, :b 20}

The empty keys vector occurs in scenarios where you search on nested maps and later want to update the nested map structure at found paths.

A well-defined behavior is to check the case when the keys vector is empty and then apply only the given function on the given map: (apply f m args)

[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-1054] Syntax quoted form produces a sequence, not a list

Tue, 18 Sep 2012 06:42:46 -0500

Syntax quote returns clojure.lang.Cons instead of IPersistenList.
But simple quote always returns list.

(list? '(1))     => true
(list? '(1 2 3)) => true
(list? `(1))     => true
(list? `(1 2 3)) => false

[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-1051] Recursive function raises "call unbound fn" exception

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

I've tried to reduce the code to the minimum that will reproduce the problem. This is a parser combinator library that uses the "list of successes" method. The test is a simple expression for adding one-digit integers with support for parens; sample input might be "1+(2+3)+4".

Having declared the parsers (see attached file), the expression parser is this:

(declare expr)

(def factor
  (choice (between (match \() (match \)) expr)
	  integer))

(def expr
  (bind factor
       (fn [t]
	 (choice (bind (match \+) (fn [_] (bind expr (fn [e] (result (+ t e))))))
	         (result t)))))

With the above, I get this error:

Clojure 1.4.0
user=> (load-file "expr.clj")
#'user/expr
user=> (run expr "(3)")      
IllegalStateException Attempting to call unbound fn: #'user/expr  clojure.lang.Var$Unbound.throwArity (Var.java:43)

I can, however, avoid this error if I code the (factor) function by expanding the code of the parser (between):

(declare expr)

(def factor*
  (choice (bind (match \() (fn [_]
          (bind expr       (fn [e]
	  (bind (match \)) (fn [_] (result e)))))))
	  integer))

(def expr
  (bind factor*
       (fn [t]
	 (choice (bind (match \+) (fn [_] (bind expr (fn [e] (result (+ t e))))))
	         (result t)))))

And now I can do:

Clojure 1.4.0
user=> (load-file "expr.clj")
#'user/expr
user=> (run expr "(3)")      
3
user=> (run expr "1+(2+3)+(4+5)")
15

The ability to reuse parser and add conveniences like (between) is key for this style of parsing.

[CLJ-1050] Remove a lock in the common case of deref of delay

Tue, 18 Sep 2012 06:53:01 -0500

Currently, when deref is called in Delay.java, a lock on the Delay is always acquired.
This is wasteful as most of the time you just want to read the val.

The attached patch changes this behaviour to the following:

val is initialised to a known secret value. (During its constructor so it is visible from any thread).
When deref is called, val is checked to the known secret value.

If it is not the secret value, then it has to be the value computed by the function and we return it.
If it is the secret value, then we lock this object and revert to the current behaviour.

This is faster than what is done currently and can be very much faster if there is contention on the delay.

[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-1042] [PATCH] Allow negative substring indices for (subs)

Wed, 19 Sep 2012 13:34:50 -0500

This adds Python-style negative string indices for (subs), e.g.:

(subs "foo bar" -3) ;; -> "bar"

[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-1040] reduce-kv on sorted maps should reduce, in sorted order

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

Currently reduces, but not in sorted order.

[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-1035] Remove the need to use ":import" of a record

Fri, 10 Aug 2012 14:19:55 -0500

Right now if I need to use a record defined in another name space, I need to do this:

(ns myproj.test.xyz
(:use [myproj.xyz])
(:import [myproj.xyz MyRecord])

Hope we can remove the need of ":import" clause.

[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-1028] (compile) crashes with NullPointerException if public function 'load' is defined

Fri, 20 Jul 2012 22:06:22 -0500

When performing AOT compilation, if the namespace being compiled or one of the namespaces :required by it defines a public function named 'load', the compiler will crash with a NullPointerException.

The following code demonstrates this:

(ns ca.ancilla.kessler.core (:gen-class)) (defn load [x] x) (defn -main [& args] 0)

When run directly, with 'clojure -m ca.ancilla.kessler.core' or 'clojure ca/ancilla/kessler/core.clj', it runs as expected. When loaded with 'clojure -i' and (compile)d, however, or when automatically compiled by 'lein run', it results in a NullPointerException (the complete stack trace is attached).

This occurs whether or not 'load' or actually called. It does not, however, occur if 'load' is private.

[CLJ-1025] Enable support for \x.. escaped characters.

Fri, 19 Oct 2012 19:59:47 -0500

see: https://groups.google.com/d/topic/clojure/Kl3WVtEE3FY/discussion

\x.. characters (which are the same as \u00.. characters) are produced by some systems. in particular clojurescript

Inability to read these characters hinders data interchange

After a quick look, I believe this capability can be easily introduced by adding a case to this
https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/LispReader.java#L445 function.
Mirroring 'u' case and reading only 2 chars.

[CLJ-1024] Varargs protococol impls can be defined but not called

Thu, 14 Feb 2013 10:03:07 -0600

The compiler accepts this:

(deftype foo []
clojure.lang.IFn
(invoke [this & xs]))

However calling ((foo.) :bar) will throw an AbstractMethodError. Wouldn't some checking be desirable?

[CLJ-1023] non-tail-position try block breaks mutable fields in deftype

Mon, 3 Dec 2012 10:55:08 -0600

The :unsynchronized-mutable fields of a deftype cannot be set! inside a try block that is not in tail position of the method.

See file *demonstration.clj* for an complete code example.

[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-1018] range's behavior is inconsistent

Fri, 24 May 2013 07:34:58 -0500

Problem statement: The current behavior of range is inconsistent. (range 0 9 0) has always produced (). (range 0 9 -1) has always produced (). (range 9 0 1) has always produced (). However, (range 9 0 0) produces (9 9 9 9 ...), and (range 0 0 0) produces '(0 0 0 0 ...)

Proposal: Make the behavior of range consistent when using a step of 0 to make it produce an empty list.

Please see attached code and patch.

[CLJ-1014] Latest Clojure master doesn't build

Fri, 20 Jul 2012 16:49:29 -0500

Compile fails with the following error:

compile-clojure:
[java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] [java] Compiling clojure.core to /home/ezyang/Dev/clojure/target/classes
Compiling clojure.core.protocols to /home/ezyang/Dev/clojure/target/classes
Compiling clojure.core.reducers to /home/ezyang/Dev/clojure/target/classes
Exception in thread "main" java.lang.ClassNotFoundException: jsr166y.ForkJoinPool, compiling:(clojure/core/reducers.clj:56)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6462)
at clojure.lang.Compiler.analyze(Compiler.java:6262)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6443)
at clojure.lang.Compiler.analyze(Compiler.java:6262)
at clojure.lang.Compiler.analyze(Compiler.java:6223)
at clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5618)
at clojure.lang.Compiler$FnMethod.parse(Compiler.java:5054)
at clojure.lang.Compiler$FnExpr.parse(Compiler.java:3674)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6453)
at clojure.lang.Compiler.analyze(Compiler.java:6262)
at clojure.lang.Compiler.analyze(Compiler.java:6223)
at clojure.lang.Compiler$NewExpr$Parser.parse(Compiler.java:2478)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6455)
at clojure.lang.Compiler.analyze(Compiler.java:6262)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6443)
at clojure.lang.Compiler.analyze(Compiler.java:6262)
at clojure.lang.Compiler.access$100(Compiler.java:37)
at clojure.lang.Compiler$DefExpr$Parser.parse(Compiler.java:518)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6455)
at clojure.lang.Compiler.analyze(Compiler.java:6262)
at clojure.lang.Compiler.analyze(Compiler.java:6223)
at clojure.lang.Compiler.compile1(Compiler.java:7030)
at clojure.lang.Compiler.compile1(Compiler.java:7025)
at clojure.lang.Compiler.compile1(Compiler.java:7025)
at clojure.lang.Compiler.compile(Compiler.java:7097)
at clojure.lang.RT.compile(RT.java:387)
at clojure.lang.RT.load(RT.java:427)
at clojure.lang.RT.load(RT.java:400)
at clojure.core$load$fn__4919.invoke(core.clj:5424)
at clojure.core$load.doInvoke(core.clj:5423)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.core$load_one.invoke(core.clj:5236)
at clojure.core$compile$fn__4924.invoke(core.clj:5435)
at clojure.core$compile.invoke(core.clj:5434)
at clojure.lang.Var.invoke(Var.java:415)
at clojure.lang.Compile.main(Compile.java:81)
Caused by: java.lang.ClassNotFoundException: jsr166y.ForkJoinPool
at java.net.URLClassLoader$1.run(URLClassLoader.java:217)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:205)
at clojure.lang.DynamicClassLoader.findClass(DynamicClassLoader.java:61)
at java.lang.ClassLoader.loadClass(ClassLoader.java:321)
at java.lang.ClassLoader.loadClass(ClassLoader.java:266)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:264)
at clojure.lang.RT.classForName(RT.java:2043)
at clojure.lang.Compiler$HostExpr.maybeClass(Compiler.java:957)
at clojure.lang.Compiler$HostExpr.access$400(Compiler.java:736)
at clojure.lang.Compiler$NewExpr$Parser.parse(Compiler.java:2473)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6455)
... 35 more

[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-1007] Faster empty map creation, default to PersistentArrayMap when converting an obj-map whose lenght is less than cljs.core.PersistentArrayMap/HASHMAP_THRESHOLD

Thu, 7 Jun 2012 10:48:36 -0500

Faster empty map creation, default to PersistentArrayMap when converting an obj-map whose lenght is less than cljs.core.PersistentArrayMap/HASHMAP_THRESHOLD

[CLJ-1006] Quotient on bigdec may produce wrong result

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

Hi,

As discussed on the mailing list in the message "When arithmetic on a computer bite back" (01/jun)

There may be bug in the way quotient is implemented for bigdec.

user> (quot 1.4411518807585587E17 2) ;; correct with doubles
7.2057594037927936E16
user> (quot 1.4411518807585587E+17M 2) ;; wrong with BigDecs
72057594037927935M

–
Laurent

[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-999] Wrong link in gh-pages index (api-index.html)

Mon, 20 May 2013 16:24:12 -0500

The api-index.html includes wrong links for the following:

All entries for all listed as part of clojure.test.tap
All entries for all listed as part of clojure.test.junit
All entries for all listed as part of clojure.core.protocols

The links point to pages that do not exist. The problem is that the documentation for those entries is on a "parent" page, for example, the link clojure.core.protocols-api.html#clojure.core.protocols/internal-reduce should have been clojure.core-api.html#clojure.core.protocols/internal-reduce

Not a huge bug for me, but you might want to get it fixed.

And please give my huge thanks to whoever is in charge of the documentation, I'm the developer behind Dash, a Mac OS X documentation browser, and I was in the process of creating a documentation set for Clojure, and because you guys have an index, you made my work 1000 times easier.

[CLJ-998] doc string for replace-first mentions non-existent replace-all

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

The doc string for clojure.string/replace-first says see also replace-all, which does not exist. The actual function is simply 'replace'.

[CLJ-996] alter-var-root + protocol function call results in StackOverflow

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

The following code:

(ns example.core)

(defprotocol Foo
  (foo [x]))

(extend-protocol Foo
  Object (foo [x] x)
  nil (foo [x] nil))

(defn apply-foo [f]
  (fn [& args]
    (foo (apply f args))))

(alter-var-root #'assoc apply-foo)

takes forever to compile from emacs+swank. Running from lein repl results in following:

user=> (use 'example.core)
StackOverflowError   clojure.lang.ArrayChunk.<init> (ArrayChunk.java:28)

If delete the foo call from the apply-foo:

(defn apply-foo [f]
  (fn [& args]
    (apply f args)))

then code compiles and executes fine.

This is true not only for assoc, but also for conj, into and possibly some other functions. Note also that crashes was seen even when the protocol function is not called, but there is call to satisfies? in the apply-foo function (although it's not clear for me how to reproduce it). Tested on clojure 1.3 and 1.4.

[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-984] Expose minKey and maxKey on PersistentTreeSet

Mon, 7 May 2012 12:05:07 -0500

I have found it occasionally useful to be able to get the minimum or maximum of a sorted set. PersistentTreeMap already has public minKey and maxKey methods; I suggest adding public minKey and maxKey methods to PersistentTreeSet (which obviously will just call the relevant methods on the impl map).

[CLJ-982] Implement an interface? predicate to balance class?

Sat, 9 Jun 2012 09:08:46 -0500

clojure.core implements a class? predicate to detect if a thing is an instance of java.lang.Class. The attached patch implements interface? to further distinguish classes that are also interfaces. This gives us Clojure api for e.g., enumerating all interfaces a thing's base class implements; as in, (filter #(interface? %) (supers (class my-thing))).

[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-974] TAP test runner broken in clojure.test

Sun, 15 Apr 2012 18:53:21 -0500

While playing with clojure.test, I discovered that the TAP test runner is broken. Some calls were missing parameters, some had too many, and the test runner was missing a handler for failures (versus errors).

[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-967] java.io/do-copy can still garble multibyte characters on IBM JDK 1.5 and 1.6

Fri, 1 Mar 2013 09:43:02 -0600

Same issue as ~~CLJ-886~~, but while the patch applied for that issue fixes the problem for many OS/JDK combos, there appear to be differences in how surrogate pair characters are handled in some OS/JDK combos. In particular, at least Linux + IBM JDK 1.5 and Linux + IBM JDK 1.6 still fail the tests checked in for do-copy.

[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-956] [java.lang.ClassFormatError: Duplicate method name&signature] when using gen-class

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

Hi,

When extending a class that defines a method with the signature "public void load();", I get the following load time error:

java.lang.ClassFormatError: Duplicate method name&signature

Looking into javap, I see that in fact gen-class is generating two entries for the load method. Prefix does not help in this case, as the defined load method is generated anyway.

Cheers,

Daniel

[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-951] Clojure 1.3+ can't intern a dynamic var

Fri, 30 Nov 2012 15:58:02 -0600

In Clojure 1.3+, interned vars don't set the dynamic field in clojure.lang.Var and can't be used in a binding:

user=> (intern ns (with-meta 'dyna-var {:dynamic true}) 100)
user=> (binding [dyna-var "one hundred"] dyna-var)
;=> IllegalStateException Can't dynamically bind non-dynamic var: user/dyna-var clojure.lang.Var.pushThreadBindings (Var.java:339)

The var has the right metadata

user=> (meta #'dyna-var)
;=> {:ns #<Namespace user>, :name dyna-var, :dynamic true}

But doesn't set the dynamic flag on the var:

user=> (.isDynamic #'dyna-var)
;=> false

The push-thread-bindings function looks for the .dynamic flag. Vars created via def have it:

user=> (def ^:dynamic def-dyna-var 100)
user=> (.isDynamic #'def-dyna-var)
;=> true

Along with the metadata

user=> (meta #'def-dyna-var)
{:ns #<Namespace user>, :name def-dyna-var, :dynamic true, :line 6, :file "NO_SOURCE_PATH"}

[CLJ-950] Function literals behavior differ from that of fns

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

((fn [] true)) ; true
(#(true)) ; classcast exception

((fn [])) ; nil
(#()) ; ()

(some (fn [_]_) [nil false 0 1]) ; 0
(some #(%) [nil false 0 1]) ; NPE

[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-947] It would be very useful to be able to annotate the constructors of classes created with gen-class

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

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-945] clojure.string/capitalize can give wrong result if first char is supplementary

Fri, 1 Mar 2013 09:43:19 -0600

When the first unicode code point of a string is supplementary (i.e. requires two 16-bit Java chars to represent in UTF-16), and that first code point is changed by converting it to upper case, clojure.string/capitalize gives the wrong answer.

[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-930] cljs.core// does not work in ClojureScript

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

clojure.core// is hard coded into the reader as a special case. cljs.core// should similarly be hard coded

[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-926] Instant literals do not round trip correctly

Fri, 17 Feb 2012 15:55:14 -0600

When using java.util.Date for instant literals (which is the default) instants do not round-trip properly during daylight savings. Here is an example:

(read-string "#inst \"2010-11-12T13:14:15.666-06:00\"")
#inst "2010-11-13T06:14:15.666+10:00"

I'm currently in Melbourne, which is normally GMT+10. However, on November 12th daylight savings is in effect, so the proper GMT offset is +11. The date above is actually using the correct local time (6:14:15) but with the wrong offset. The problem is more obvious when you attempt to round-trip the instant that was read.

user> #inst "2010-11-13T06:14:15.666+10:00"
#inst "2010-11-13T07:14:15.666+10:00"

Notice that we read 6:14am but the output was 7:14 with the same offset. Upon digging deeper the real culprit seems to be the use of String.format (through clojure.core/format) when outputting java.util.Date. Notice the following inside caldate->rfc3339

(format "#inst \"%1$tFT%1$tT.%1$tL%1$tz\"" d))

Let's compare the timezone offset in the underlying date with what is printed by %1$tz

user> (def d #inst "2010-11-13T06:14:15.666+10:00")
#'clojure.instant/d                                                                                                                                                                                         
user> (.getHours d)
7                                                                                                                                                                                                           
user> (.getTimezoneOffset d)
-660

For reference, the definition of getTimezoneOffset is

-(Calendar.get(Calendar.ZONE_OFFSET) + Calendar.get(Calendar.DST_OFFSET)) / (60 * 1000)

So far it looks good. 6am in GMT+10 becomes 7am in GMT+11. Let's see how String.format handles it though.

                                                                                               
clojure.instant> (format "%1$tz" d)
"+1000"                                                                                                                                                                                                     
clojure.instant> (format "%1$tT" d)
"07:14:15"

String.format prints the correct hour, but with the wrong offset. The recommended way for formatting dates is to use a DateFormatter.

The String.format approach appears to work properly for Calendar, but not for Date. Therefore the attached patch keeps the current
implementation for java.util.Calendar but uses SimpleDateFormat to handle java.util.Date correctly. This fixes the roundtrip problem.

[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-922] Transient maps lose values

Tue, 31 Jan 2012 01:21:40 -0600

I have tested this on the latest clojure 1.4 alpha (1.4.0-alpha5).

I am not exactly sure what the problem is w/ transient maps, but at a certain point they appear to lose values (values that are inserted into the maps w/ assoc! do not get saved).

I have a test script that illustrates this bug:

https://gist.github.com/497879a727dabac46ec3

All the values up to content-length are saved, but content-length never makes it into the transient map.

[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-918] Vars with {:macro true} meta data do not work when loaded from AOT compiled file

Thu, 13 Sep 2012 14:29:01 -0500

When defining a var with ^{:macro true} the call of the binded macro does emit a warning when the definition has been AOT compiled.

See example outputs with demo code here: https://refheap.com/paste/389

Bronsa on #clojure created a patch: http://sprunge.us/bWcc

[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-915] Add support for instance literals using planned Clojure 1.4 tagged literal capability.

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

Using the tagged literal facility added in Clojure 1.4-alpha4, add support for an instance literal, adhering to RFC 3339 of the form:

date-year   = 4DIGIT
date-month      = 2DIGIT  ; 01-12
date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on
                         ; month/year
time-hour       = 2DIGIT  ; 00-23
time-minute     = 2DIGIT  ; 00-59
time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second
                         ; rules
time-secfrac    = '.' 1*DIGIT
time-numoffset  = ('+' / '-') time-hour ':' time-minute
time-offset     = 'Z' / time-numoffset

time-part            = time-hour [ ':' time-minute [ ':' time-second [time-secfrac] [time-offset] ] ]

timestamp       = date-year [ '-' date-month [ '-' date-mday [ 'T' time-part ] ] ]

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

[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-913] slurp fails on /proc files (linux)

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

On my machine,
(slurp "/proc/cpuinfo")
fails with:
java.io.IOException: Argument invalide (NO_SOURCE_FILE:0)

whereas the following succeeds:
(with-open [f (java.io.FileReader. "/proc/cpuinfo")] (slurp f))

[CLJ-912] clojure.java.browse/browse-url fails to open http://localhost:3000 with swing backend

Mon, 12 Mar 2012 13:24:37 -0500

I've got the following exception after launching (clojure.java.browse/browse-url "http://localhost:3000"):

java.lang.RuntimeException: java.io.FileNotFoundException: http://localhost:3000
at clojure.lang.Util.runtimeException(Util.java:165)
at clojure.lang.Reflector.invokeConstructor(Reflector.java:193)
at clojure.java.browse_ui$open_url_in_swing.invoke(browse_ui.clj:15)
at clojure.lang.Var.invoke(Var.java:401)
at clojure.java.browse$open_url_in_swing.invoke(browse.clj:44)
at clojure.java.browse$browse_url.invoke(browse.clj:52)
at user$eval1689.invoke(NO_SOURCE_FILE:1)
at clojure.lang.Compiler.eval(Compiler.java:6465)
at clojure.lang.Compiler.eval(Compiler.java:6431)
at clojure.core$eval.invoke(core.clj:2795)
at swank.commands.basic$eval_region.invoke(basic.clj:47)
at swank.commands.basic$eval_region.invoke(basic.clj:37)
at swank.commands.basic$eval845$listener_eval__846.invoke(basic.clj:71)
at clojure.lang.Var.invoke(Var.java:401)
at user$eval1687.invoke(NO_SOURCE_FILE)
at clojure.lang.Compiler.eval(Compiler.java:6465)
at clojure.lang.Compiler.eval(Compiler.java:6431)
at clojure.core$eval.invoke(core.clj:2795)
at swank.core$eval_in_emacs_package.invoke(core.clj:92)
at swank.core$eval_for_emacs.invoke(core.clj:239)
at clojure.lang.Var.invoke(Var.java:409)
at clojure.lang.AFn.applyToHelper(AFn.java:167)
at clojure.lang.Var.applyTo(Var.java:518)
at clojure.core$apply.invoke(core.clj:600)
at swank.core$eval_from_control.invoke(core.clj:99)
at swank.core$eval_loop.invoke(core.clj:104)
at swank.core$spawn_repl_thread$fn_527$fn_528.invoke(core.clj:309)
at clojure.lang.AFn.applyToHelper(AFn.java:159)
at clojure.lang.AFn.applyTo(AFn.java:151)
at clojure.core$apply.invoke(core.clj:600)
at swank.core$spawn_repl_thread$fn__527.doInvoke(core.clj:306)
at clojure.lang.RestFn.invoke(RestFn.java:397)
at clojure.lang.AFn.run(AFn.java:24)
at java.lang.Thread.run(Thread.java:679)
Caused by: java.io.FileNotFoundException: http://localhost:3000
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at java.lang.reflect.Constructor.newInstance(Constructor.java:532)
at sun.net.www.protocol.http.HttpURLConnection$6.run(HttpURLConnection.java:1458)
at java.security.AccessController.doPrivileged(Native Method)
at sun.net.www.protocol.http.HttpURLConnection.getChainedException(HttpURLConnection.java:1452)
at sun.net.www.protocol.http.HttpURLConnection.getInputStream(HttpURLConnection.java:1106)
at javax.swing.JEditorPane.getStream(JEditorPane.java:827)
at javax.swing.JEditorPane.setPage(JEditorPane.java:433)
at javax.swing.JEditorPane.setPage(JEditorPane.java:939)
at javax.swing.JEditorPane.<init>(JEditorPane.java:273)
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at java.lang.reflect.Constructor.newInstance(Constructor.java:532)
at clojure.lang.Reflector.invokeConstructor(Reflector.java:183)
... 32 more
Caused by: java.io.FileNotFoundException: http://localhost:3000
at sun.net.www.protocol.http.HttpURLConnection.getInputStream(HttpURLConnection.java:1401)
at java.net.HttpURLConnection.getResponseCode(HttpURLConnection.java:397)
at javax.swing.JEditorPane.getStream(JEditorPane.java:792)
... 40 more

It works with urls like http://google.com:80, so probably the problem is in the combination of one-segment domen and port.

Note: I use Ubuntu 11.10 with Chromium as a default browser. I'm not sure why browse-url fails to open urls via standart browser. Should I create another issue for that or is it a java problem?

[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-908] Functions with metadata print poorly

Fri, 24 May 2013 07:55:08 -0500

1.3 removed the metadata slot on most functions, and made .withMeta return a new wrapping function that provides metadata. This changes the way functions with metadata print: instead of #<user$eval595$fn_596 user$eval595$fn_596@3d48ff04> we now see #< clojure.lang.AFunction$1@581de498>. I might argue that we should "lie" and print the class of the original wrapped function since it's more useful than AFunction$1, but that's debatable. The two things I propose changing are:

When *print-meta* is true, we should print the metadata map for functions. That nothing prints implies there is no metadata, which can make it difficult to track down bugs related to metadata on functions.
Remove the errant space at the front of the printed representation of functions with meta, changing #< clojure.lang.AFunction$1@581de498> to #<clojure.lang.AFunction$1@581de498>. The cause of this issue is that .getSimpleName on an object with an anonymous class returns "", and we print that followed by a space and its .toString. My fix is to omit the extra space if the class has no simple name; this would cause instances of other anonymous (non-function) classes to print more nicely as well.

If it would be desirable to print the class of the original "wrapped" function, then I can easily add another patch for that.

[CLJ-907] records do not enforce type hints

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

Specify a record with a field as say ^String, but the constructor won't throw if you pass in a non-String.

[CLJ-906] defrecord with protocol implementation fails when field and method names collide

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

The following produces a NullPointerException:

(defprotocol Foo (act [this]))
(defrecord Fred []
Foo
(act [this] (println "done.")))
(defrecord Bar [act] ;; <<<<<======= Field name is the same as method name.
Foo
(act [this] (act (Fred.)))) ;; <<<<<====== Behaves as (nil (Fred.))
(act (Bar. nil))

Produces:
Exception in thread "main" java.lang.NullPointerException
at protocol.Bar.act(protocol.clj:8)
at protocol$eval66.invoke(protocol.clj:9)
at clojure.lang.Compiler.eval(Compiler.java:6465)
at clojure.lang.Compiler.load(Compiler.java:6902)
at clojure.lang.Compiler.loadFile(Compiler.java:6863)
at clojure.main$load_script.invoke(main.clj:282)
at clojure.main$script_opt.invoke(main.clj:342)
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)

–

The following works as expected:

(defprotocol Foo (act [this]))
(defrecord Fred []
Foo
(act [this] (println "done.")))
(defrecord Bar [x] ; <<== Field name is the DIFFERENT than method name
Foo
(act [this] (act (Fred.))))
(act (Bar. [1 2 3]))

Produces:
"done."

–

The following also works:

(defprotocol Foo (act [this]))
(defrecord Fred [])
(defrecord Bar [act]) ; <<== Field name is the same as method name
(extend-protocol Foo
Fred
(act [this] (println "done."))
Bar
(act [this] (act (Fred.))))
(act (Bar. [1 2 3]))

[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-901] implementation of doc macro in core.repl incorrect for special names... add one character to fix

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

In the implementation of the doc macro in core.repl, the line:
(if-let [special-name ('{& fn catch try finally try} name)]
contains:{& fn catch try finally try} which is a hashmap.

It should be a set, and the line should read:
(if-let special-name ('#{& fn catch try finally try} name)

To see the bug at work:
user> (doc &)
-------------------------
clojure.core/fn
(fn name? [params*] exprs*)
(fn name? ([params*] exprs*) +)
Special Form
params => positional-params* , or positional-params* & next-param
positional-param => binding-form
next-param => binding-form
name => symbol

Defines a function

Please see http://clojure.org/special_forms#fn

[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-896] Make browse-url aware of xdg-open

Fri, 24 May 2013 07:55:10 -0500

clojure.java.browse/browse-url tests to see if it's running on Mac OS to fall back to "/usr/bin/open" in order
to open a URI. On most other systems it'll just falls through to open-url-in-swing instead. The attached patch
tests to see if freedesktop.org's "xdg-open" is present in the users path. This way browse-url will launch the
program associated with the URI, in my case chromium.

[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-894] Better reduce performance

Fri, 13 Apr 2012 08:05:24 -0500

Currently reduce is implemented in Clojure by calling seq on a collection. Construction of an entire new seq is an unnecessary and expensive operation, particularly for the key persistent collections (map, set and vector suffer - list is not a problem because it implements ISeq directly for free).

This patch proposes to improve this by doing the following:
1. Make use of a Java interface for reducible collections (IReduce)
2. Make persistent collections support implementations of reduce
directly by implementing IReduce
3. Modify the internal-reduce protocol to operate on concrete
collections (not just seqs) and make use of IReduce implementations
where available
4. Change reduce itself to call internal-reduce directly rather than
calling seq first

[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-883] Clojure head holding bug

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

I've a head holding problem that I believe is a bug in clojure 1.3. I
wrote the following function to split a a lazy seq of strings across
files of x size:

(defn split-file
 ([path strs size]
    (trampoline split-file path (seq strs) size 0))
 ([path strs size part]
    (with-open [f (clojure.java.io/writer (str path "." part))]
      (loop [written 0, ss strs]
        (when ss
          (if (>= written size)
            #(split-file path ss size (inc part))
            (let [s (first ss)]
              (.write f s)
              (recur (+ written (.length s)) (next ss)))))))))

If I call the 3 arg version of the function:
(split-file "foo" (repeat 100000000 "blah blah blah") 100000000)

I see memory usage increases as I'm writing each file with the usual
gc slow down, then memory usage goes back down again as I get to a new
split file.

Memory usage is fine if I call the 4 arg version (which only writes
one part of the split file):
(split-file "foo" (repeat 100000000 "blah blah blah") 100000000 0)

I can also avoid the head holding problem by removing trampoline and
recursively calling split-file directly, but then those recursive
calls use up stack and don't close files until all calls complete

[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-877] contains? is broken for vectors

Mon, 14 Nov 2011 12:45:35 -0600

contains? returns the wrong result for the last item in a vector:

user> (map #(contains? [1 2 3 4] %) [1 2 3 4])
(true true true false)

[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-875] Clojure's seq, keys, and vals can produce inconsistent values on strange iterators (e.g., IdentityHashMap)

Fri, 2 Dec 2011 09:28:16 -0600

user> clojure-version
{:major 1, :minor 4, :incremental 0, :qualifier "alpha1"}
user> (def x (keys (java.util.IdentityHashMap. {:a true :b true})))
#'user/x
user> x
(:b :a)
user> x
(:a :a)

As discussed on the mailing list, it's not clear exactly whose fault this is:
https://groups.google.com/group/clojure-dev/browse_frm/thread/bed458abf8e266aa#
given that the javadocs for iterators and entrySet dont' seem to require (or mention at all) whether each .next() must return a unique value.

keys and vals could be fixed by using keySet and values rather than entrySet, at least in this case, but this would not help for seq.

[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-873] Allow the function / to be referred to in namespaces other than clojure.core

Fri, 24 May 2013 08:39:11 -0500

The attached patch gives the programmer the option of referring to the division function in namespaces other than just clojure.core. For example,

(ns foo
(:require [cljs.core :as core]))
(apply core// '(1 2 3))

The above lines do not compile without this patch.

[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-869] Macro auto-gensym in let not visible after a nested unquote/syntax-quote

Fri, 2 Dec 2011 10:42:59 -0600

See the following simplified example:

user=> (defmacro foo [flag]
        `(let [a# 1]
          ~(if flag
             `(println a#))))
#'user/foo
user=> (foo false)
nil
user=> (foo true)
java.lang.Exception: Unable to resolve symbol: a__574__auto__ in this context (NO_SOURCE_FILE:6)
user=> (macroexpand-1 '(foo true))
(clojure.core/let [a__575__auto__ 1] (clojure.core/println a__574__auto__))

[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-863] interleave should accept 1 or 0 arguments

Fri, 24 May 2013 07:55:10 -0500

interleave should handle 0 and 1 arguments in the same way that concat does (i.e., 0 args --> empty seq, 1 args --> identity).

[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.

All inactive Clojure issues (Clojure JIRA)

[CLJ-1203] Fallback to hash-based comparison for non-Comparables in Util.compare()

[CLJ-1196] eval of defrecord instance with no fields produces {}, not itself

[CLJ-1194] Typo in core.reducers

[CLJ-1188] Public Java API

[CLJ-1179] distinct? does not accept zero arguments

What (small set of) steps will reproduce the problem?

What is the expected output? What do you see instead?

What version are you using?

[CLJ-1178] Requiring the same ns doesn't throw an exception

[CLJ-1174] Website doc link for 1.4 api docs returns a 404

[CLJ-1173] One-arg protocol functions whose name begins in a dash generates a call to a wrong field in the emitted code

[CLJ-1170] conj-ing x on equal values should produce equal results

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

[CLJ-1166] Range function accumulates minor errors when called on floating-point numbers

[CLJ-1164] typos in instant.clj

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

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

[CLJ-1156] clojure.walk/stringifiy-keys does not stringify non-keyword keys

[CLJ-1155] Suppress tracebacks from clojure.core

[CLJ-1153] Change *read-eval* default value to false

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

[CLJ-1145] thread-last can't accept 0 or 1 forms, thread-first can't accept 0 forms

[CLJ-1143] Minor correction to doc string of ns macro

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

[CLJ-1139] Compiler exception while compiling swank/commands/basic.clj

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

[CLJ-1129] Invalid ns macro can yield a difficult to trace exception

[CLJ-1123] UNIX/Windows line endings - clojure.pprint tests cause failure in Windows build

[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-1101] *default-data-reader-fn* should be set!-able in REPL

[CLJ-1099] better error message when passing non-seq to seq

[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-1089] clojure.java.io/copy interprets read count of 0 as eos

[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-1075] deftype: compiler error on set! for mutable field

[CLJ-1072] Replace old metadata reader macro syntax

[CLJ-1071] ExceptionInfo does no abstraction

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

[CLJ-1069] data.priority-map has no artifacts information in the README

[CLJ-1068] algo.monads README has no artifacts information

[CLJ-1067] Fix error message inconsistencies in Symbol and Keyword

[CLJ-1066] No dependency on jsr166y

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

[CLJ-1064] Broken update-in for empty keys vector

[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-1054] Syntax quoted form produces a sequence, not a list

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

[CLJ-1051] Recursive function raises "call unbound fn" exception

[CLJ-1050] Remove a lock in the common case of deref of delay

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

[CLJ-1042] [PATCH] Allow negative substring indices for (subs)

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

[CLJ-1040] reduce-kv on sorted maps should reduce, in sorted order

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

[CLJ-1035] Remove the need to use ":import" of a record

[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-1028] (compile) crashes with NullPointerException if public function 'load' is defined

[CLJ-1025] Enable support for \x.. escaped characters.

[CLJ-1024] Varargs protococol impls can be defined but not called

[CLJ-1023] non-tail-position try block breaks mutable fields in deftype

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

[CLJ-1018] range's behavior is inconsistent

[CLJ-1014] Latest Clojure master doesn't build

[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-1007] Faster empty map creation, default to PersistentArrayMap when converting an obj-map whose lenght is less than cljs.core.PersistentArrayMap/HASHMAP_THRESHOLD

[CLJ-1153] Change read-eval default value to false

[CLJ-1101] default-data-reader-fn should be set!-able in REPL

[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