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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-851] Type-hinting a var with primitive array pseudo-class results in IllegalArgumentException when the var is used as an arg

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

Example:

user=> (def ^longs la (long-array 0))
#'user/la
user=> (defn foo [] (alength la))
CompilerException java.lang.IllegalArgumentException: Unable to resolve classname: clojure.core$longs@32dfcb47, compiling:(NO_SOURCE_PATH:9)

Workaround: use the class string, e.g., ^"[J"

[CLJ-848] defn :or form does not warn you if you provide a vector instead of a map

Tue, 25 Oct 2011 18:04:23 -0500

I had a problem defining a function today, I passed :or a vector instead of a map - everything seemed to work fine but later on I got a really puzzling "Null pointer exception".

raek helped me debug the problem and suggested opening this ticket. I think it would be useful if an exception was thrown on the :or line unless it's given a map.

Here are some examples

(defn broken-example [{:keys [i processor]
:or [processor identity]}]
(processor i))

(defn working-example [{:keys [i processor]
:or {processor identity}}]
(processor i))

(working-example {:i 1})
=> 1
(broken-example {:i 1})
=> Null pointer exception

Cheers, Dave.

[CLJ-841] Unable to download clojure using wget. Wget seems to be blocked...

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

wget http://repo1.maven.org/maven2/org/clojure/clojure/1.3.0/clojure-1.3.0.zip
Gives me a 403, same with other people.

When I add -U YUBLOCKWGET to the command, it downloads the file successfully.

This "feature" needs to be removed.

Also, I encountered this while trying to package clojure 1.3. So no, I can't just use a browser

[CLJ-826] Include drop, take, butlast from clojure.contrib.string (1.2) in clojure.string 1.3

Fri, 2 Dec 2011 09:14:37 -0600

From clojure.contrib.string 1.2, I have found myself using drop, take,
and butlast. (These are more than just wrappers for String/substring,
because they behave nicely when indices exceed the string length.) I
like these methods in part because they match the behavior of
corresponding sequence methods, but have better performance. This
makes optimizing (when needed) easier.

[CLJ-820] int coercion doesn't work in clojure 1.3

Fri, 20 Jul 2012 16:54:48 -0500

Using the clojure git head as of 2011-07-14 (commit f704853751d02faf72bd53be599ee0be6c1da63e), int coercion doesn't work:

user> (class (int 1))
java.lang.Long

byte, short, double, and float coercion work fine, though:

user> (class (byte 1))
java.lang.Byte
user> (class (short 1))
java.lang.Short
user> (class (double 1))
java.lang.Double
user> (class (float 1))
java.lang.Float

Also creating integers directly works fine:

user> (class (Integer. "100"))
java.lang.Integer
user> (class (Integer/valueOf 1))
java.lang.Integer
user> (class (Integer. 100))
java.lang.Integer

This is probably related to ~~CLJ-439~~.

[CLJ-819] deftype print/read doesn't munge field names

Wed, 24 Aug 2011 05:05:23 -0500

Example:

=> *clojure-version*
{:major 1, :minor 3, :incremental 0, :qualifier "beta1"}
=> (deftype P [a-b])
user.P
=> (P. "foo")
#<IllegalArgumentException java.lang.IllegalArgumentException: No matching field found: a-b for class user.P>

The field names being passed along to the reflector need to be munged properly in core_print.clj (line 246), and the Compiler needs to do the same in the IType block in ObjExpr.emitValue.

[CLJ-818] doc string for resolve mentions &env

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

(defn resolve
"same as (ns-resolve ns symbol) or (ns-resolve ns &env symbol)"

The ampersand on "&env" in the doc string is distracting. There's no macro magic involved so it should just say "env".

[CLJ-814] Make the #= reader macro an official" part of the language

Tue, 28 Jun 2011 18:25:10 -0500

Can the #= reader macro be made "official" by documenting it on the clojure.org website. It seems to be quite useful for several applications, including regular macro definitions.

[CLJ-810] clojure.set/difference

Mon, 20 Jun 2011 07:04:37 -0500

This seems a bit weird. Maybe set difference could check that the collections are sets?

(clojure.set/difference (set [0 300 :a]) [:a :b])
#{0 300}
(clojure.set/difference (set [0 300 :a]) [:a :b :c :d])
#{:a 300}
(clojure.set/difference (set [0 300 :a]) (set [:a :b :c :d]))
#{0 300}

The problem is still present in the master branch too.

[CLJ-804] Expose memoization cache and original as metadata on memoized functions.

Tue, 21 Jun 2011 18:04:42 -0500

The attached patch exposes the memoization cache and original pre-memoized value as metadata on memoized functions.

The metadata keys are ::memoize-cache and ::prememoized respectively, to which I'm not too attached.

[CLJ-799] ArrayMaps print-dup with read-eval

Fri, 27 May 2011 07:38:26 -0500

user=> (binding [*print-dup* true] (print-str (hash-map :k :v)))
"{:k :v}"
user=> (binding [*print-dup* true] (print-str {:k :v}))
"#=(clojure.lang.PersistentArrayMap/create {:k :v})"

In the top example, the reader will automatically create an array-map due to the number of entries, so unless there is an overriding reason to force type-preservation in the bottom example, it can likewise be printed as a literal map.

[CLJ-793] print-doc triggers NPE in clojure.lang.Namespace.find

Tue, 31 May 2011 09:15:10 -0500

In a swank repl I tried to invoke (print-doc ADefTypeInCurrentNamespace) and got the following exception:

No message.
[Thrown class java.lang.NullPointerException]

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

Backtrace:
0: java.util.concurrent.ConcurrentHashMap.get(ConcurrentHashMap.java:768)
1: clojure.lang.Namespace.find(Namespace.java:188)
2: clojure.core$find_ns.invoke(core.clj:3180)
3: clojure.core$the_ns.invoke(core.clj:3208)
4: clojure.core$ns_name.invoke(core.clj:3214)
5: clojure.core$print_doc.invoke(core.clj:3831)
6: les$eval36576.invoke(NO_SOURCE_FILE:1)
7: clojure.lang.Compiler.eval(Compiler.java:5424)
8: clojure.lang.Compiler.eval(Compiler.java:5391)
9: clojure.core$eval.invoke(core.clj:2382)
10: swank.commands.basic$eval_region.invoke(basic.clj:47)
11: swank.commands.basic$eval_region.invoke(basic.clj:37)
12: swank.commands.basic$eval797$listener_eval__798.invoke(basic.clj:71)
13: clojure.lang.Var.invoke(Var.java:365)
14: les$eval36574.invoke(NO_SOURCE_FILE)
15: clojure.lang.Compiler.eval(Compiler.java:5424)
16: clojure.lang.Compiler.eval(Compiler.java:5391)
17: clojure.core$eval.invoke(core.clj:2382)
18: swank.core$eval_in_emacs_package.invoke(core.clj:90)
19: swank.core$eval_for_emacs.invoke(core.clj:237)
20: clojure.lang.Var.invoke(Var.java:373)
21: clojure.lang.AFn.applyToHelper(AFn.java:169)
22: clojure.lang.Var.applyTo(Var.java:482)
23: clojure.core$apply.invoke(core.clj:540)
24: swank.core$eval_from_control.invoke(core.clj:97)
25: swank.core$eval_loop.invoke(core.clj:102)
26: swank.core$spawn_repl_thread$fn_482$fn_483.invoke(core.clj:307)
27: clojure.lang.AFn.applyToHelper(AFn.java:159)
28: clojure.lang.AFn.applyTo(AFn.java:151)
29: clojure.core$apply.invoke(core.clj:540)
30: swank.core$spawn_repl_thread$fn__482.doInvoke(core.clj:304)
31: clojure.lang.RestFn.invoke(RestFn.java:398)
32: clojure.lang.AFn.run(AFn.java:24)
33: java.lang.Thread.run(Thread.java:619)

[CLJ-785] Optimize /

Fri, 13 May 2011 09:26:14 -0500

Optimization to / such that the & more version expands to equivalent of (/ x (reduce * y more)) rather than (reduce / (/ x y) more). There should be an inlined variant of & more as well.

This was originally part of ~~CLJ-184~~, but was pulled out because it's big enough to be its own ticket. The rationale is that multiplies are significantly faster than divides on the JVM, and n-ary calls to / could be faster.

See "Java Multiplication (Much) Faster than Division" for background and Java benchmarks.

[CLJ-767] Remove support for non-primitive bit-shift operations

Wed, 25 May 2011 12:12:21 -0500

Per Rich's comment:

Shift ops would be limited to primitives only. Default versions 64-bit, but explicit shift-int versions for 32 bits.

[CLJ-762] Clojure compilation hangs

Fri, 24 Feb 2012 10:36:51 -0600

Good day, i was trying to write simple sudoku solver as learning excercise, but suddenly stuck
on some point becasue compiler hangs when trying to run my snippet (attached).

[CLJ-758] Add Clojure program to generate HTML and LaTeX cheatsheets from common source

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

Discussion thread on clojure-dev: http://groups.google.com/group/clojure-dev/browse_thread/thread/265b887a940219b2#

Steve Tayon created a cheat sheet of Clojure functions, macros, and vars organized into categories. He created it in LaTeX, editing it through several revisions. One or a few revisions were manually converted to HTML for publication at URL http://clojure.org/cheatsheet

Alex Miller proposed creating a single source that could then be used to automatically generate both HTML and LaTeX/PDF versions, where each symbol on the cheatsheet would be a link to documentation on clojure.github.com

Andy Fingerhut created a Clojure program that, from a single data structure contained within the program, generates either HTML or LaTeX, with or without the links. The LaTeX can be used to generate PDF files in either A4 or US letter size pages.

[CLJ-756] Workable upload destination for release zips

Fri, 22 Apr 2011 09:34:52 -0500

We have been using Github's file upload under http://github.com/clojure for uploading releases

Pros:

looked easy
download tracking
tool we are already using

Cons:

unreliable
- fails to upload
  - tested on multiple browsers with and without Flash
- even when it works seems to show up during upload
  - presumably would fail the download in these cases
- claims to upload but has garbage file
  - shows up in UI
  - permission error when you try to get it
  - sometimes causes browser to crash (not Github fault, but still...)
- has added two hours of dev time to the current release (so far)

In order to get 1.3.0-alpha6 out the door (and end a multihour ordeal) I am pushing it to the files section at clojure.org.

[CLJ-746] Unreference keywords not correctly removed from keyword table (Utils.clearCache)

Fri, 4 Mar 2011 21:49:42 -0600

I just ran into http://dev.clojure.org/jira/browse/CLJ-444 in clojure 1.2 and think the anlaysis there missed the cause of the issue.

Reading http://download.oracle.com/javase/1.4.2/docs/api/java/lang/ref/ReferenceQueue.html#poll() suggests poll removes an item from the queue.

In Util.clearCache, there are two calls to rq.poll() with discarded return values, with the result that some of the enqueued soft references are not being removed from cache (ie the keyword table)

[CLJ-744] proxy hides protected final methods

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

When using proxy to override a class that has a protected final method, that method is not exposed.

For example, given the class:

ProxyMe.java

public class ProxyMe {
    public final void publicFinal() {}
    protected void protectedNonFinal() {}
    protected final void protectedFinal() {}
}

And the Clojure code:

proxy_me.clj

(ns proxy-me
  (:import ProxyMe))

(def proxied-class (class (proxy [ProxyMe] [])))
(def no-args (into-array Class []))

; both are ok
(.getMethod proxied-class "publicFinal" no-args)
(.getMethod proxied-class "protectedNonFinal" no-args)

; throws NoSuchMethodException
(.getMethod proxied-class "protectedFinal" no-args)

Any attempt to access protectedFinal() fails.

[CLJ-743] Error messages for invalid destructured bindings are not helpful

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

Errors in destructured forms throw errors that give no clue to what the actual problem is. For example, evaluating (let [[a b] 3] a) throws a 'nth not supported on type Long' error. It is not obvious that the destructuring expression is at fault.

There should be another exception at the top level in the stack trace, something along the lines of of "DestructuringException: value <value> could not be destructured", with the 'nth not supported' exception as its cause.

[CLJ-732] (keyword "") can be printed, but not read

Fri, 29 Jul 2011 07:49:21 -0500

user=> (keyword "")
:
user=> (prn-str *1)
":\n"
user=> (read-string *1)
java.lang.RuntimeException: java.lang.Exception: Invalid token: : (NO_SOURCE_FILE:0)

This obviously isn't a huge defect, but I'd argue that anything that can be printed should be readable.

[CLJ-725] (;) causes repl to hang in Clojure 1.3-0-alpha3 on Mac OS X 10.6.3 Intel

Wed, 26 Jan 2011 00:30:00 -0600

From the new-to-Clojure but very excited about the language perspective, this seems simply seemed like low-priority-but-should-be-fixed-eventually bug. When I invoked ; as a function name by accident, I found that the REPL simply hung.

jaten@host151:~$ uname -a
Darwin host151.wifi.epochcoffee.com 10.3.0 Darwin Kernel Version 10.3.0: Fri Feb 26 11:58:09 PST 2010; root:xnu-1504.3.12~1/RELEASE_I386 i386

jaten@host151:~$ java -server -cp "/home/jaten/pkg/clojure/jars/*" clojure.main
Clojure 1.3.0-alpha3
user=> ( ; causes REPL to hang forever...???

Also happens in clojure 1.2.0. I didn't try any other versions.

[CLJ-724] bean throws NPE when key doesn't exist

Tue, 5 Apr 2011 20:46:42 -0500

The result of (bean obj) throws a NullPointerException when passed in a key that doen't exist. I think instead it should return nil to be consistent with maps and records - or at least the error message should be more explicit.

[CLJ-723] Add def- macro to core

Sat, 22 Jan 2011 09:49:32 -0600

Having a def- macro in core as sugar for ^:private seems consistent and nice.

[CLJ-722] Misleading documentation string in doseq

Fri, 2 Dec 2011 09:12:04 -0600

The documentation string of doseq is slightly misleading because it doesn't state that doseq will behave like "do" when the seq-exprs argument is empty.

Attached patch clarifies this.

[CLJ-717] A range function for characters, char-range

Sun, 16 Jan 2011 09:12:39 -0600

I've seen a lot of cases where people would do stuff like this:

(def alphabet "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

Or other equally meh things in order to get a range of characters. Haskell's range supports creating ranges of characters, so that was inspiration for this addition.

I've created a function that is the analogue of range for characters. I've called it char-range. It works almost precisely the same as range (and uses range under the hood), only the upper bound isn't exclusive. It made more sense to me for it to be inclusive, so that things like (char-range \a \z) work and make sense.

It takes the same argument combinations as range. For no arguments, it produces a lazy sequence of characters from Character/MIN_VALUE to Character/MAX_VALUE. For two arguments, it produces a lazy sequence from Character/MIN_VALUE to end. It allows for the same stepping that range allows for as well.

[CLJ-714] Real multi-line comments

Sat, 3 Sep 2011 22:05:50 -0500

The (comment) macro is not a viable substitute for real multi-line comments:

It evaluates to nil, so isn't really useful except at the top level
It requires proper paren/etc nesting inside itself
Contents must be valid tokens; for example TODO: is illegal inside a (comment)

Common Lisp has #|...|# for multi-line comments, and I think Clojure would benefit from having them too. I've implemented #| to behave in a way that is identical (so far as I am able to test) to CL's implementation, and added tests to the reader test to verify that they work.

Apologies for my formatting in the java files not quite matching up with the rest of the code: I didn't want to go through the pain of making it perfect unless this patch would actually be accepted; I can go back through if necessary.

[CLJ-709] Add a way to test/detect promise objects

Sat, 3 Sep 2011 22:05:51 -0500

I'd like a predicate to determine whether an object is a (promise). Currently promises are implemented as a reify of IFn and IDeref, meaning there is no meaningful superclass to test for. It seems to me the simplest solution would be to create an IPromise interface extending IDeref; then (defn promise? [x] (instance? IPromise x)) is a simple solution. Even an empty "tagging" interface for IPromise would do, but it might also be nice to add a delivered? predicate for promises so that it's possible to test whether they're delivered without blocking or catching the "multiple deliver" exception; that would make the IPromise interface more meaningful as well.

This is fairly simple stuff, so I'll start plugging away at a patch and hope nobody objects.

[CLJ-707] -> produces known-invalid code when it could be smarter

Sat, 3 Sep 2011 22:05:49 -0500

(-> inc (comp read ())

Macroexpands to (nil (comp read promise)), which is known at compile-time to be illegal code.
It seems like it would be harmless, and occasionally useful, to special-case () to expand into wrapping parens around the preceding form, such as:

((comp inc read))

I'll put together a patch for this shortly if nobody tells me it's a terrible idea.

[CLJ-694] Set func create sorted hash-set

Mon, 27 Dec 2010 12:51:05 -0600

(def _sortedset (set (list 1,3,2)))
(println _sortedset)
(println (class _sortedset))

This code output is:

>> #{1 2 3}
>> clojure.lang.PersistentHashSet

As you can see set function create hash-set, but already sorted.

[CLJ-692] Should "some" be using "seq?" rather than "seq" ?

Fri, 8 Jul 2011 03:28:42 -0500

Very minor, but noticed while browsing that "some" is defined as:

(defn some
...
[pred coll]
(when (seq coll)
(or (pred (first coll)) (recur pred (next coll)))))

The "(seq coll)" call will potentially generate an unused seq each time.

[CLJ-688] subs function should count back from the end of the string when given negative offset

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

subs function should count back from the end of the string when given negative offset.

Patch attached with test and implementation.

[CLJ-676] Calling seq on the resultset-seq of an empty ResultSet throws an exception

Fri, 17 Dec 2010 19:56:22 -0600

The clojure.sql/resultset-seq function returns a seq over the JDBC ResultSet.

Expected: calling seq on an empty ResultSet should return nil
Actual: throws an error due to a closed ResultSet

Example:

(def db {:classname "oracle.jdbc.driver.OracleDriver"
         :subprotocol "oracle:thin"
         :subname "@detroit:1521:XE"
         :user "ted"
         :password "nugent"
         :schema "sweaty"})

(with-connection db
  (with-query-results res ["SELECT 1 FROM dual WHERE 0=1"]
    (seq res)))

returns:

java.sql.SQLRecoverableException: Closed Resultset: next
  [Thrown class java.lang.RuntimeException]

Backtrace:
  0: clojure.lang.LazySeq.sval(LazySeq.java:47)
  1: clojure.lang.LazySeq.seq(LazySeq.java:56)
  2: clojure.lang.Cons.next(Cons.java:39)
  3: clojure.lang.RT.next(RT.java:560)
  4: clojure.core$next.invoke(core.clj:61)
  5: clojure.core$nthnext.invoke(core.clj:3399)
  6: clojure.core$print_sequential.invoke(core_print.clj:55)
  7: clojure.core$fn__4845.invoke(core_print.clj:138)
  8: clojure.lang.MultiFn.invoke(MultiFn.java:167)
  9: clojure.core$pr_on.invoke(core.clj:2812)
 10: clojure.core$pr.invoke(core.clj:2824)
 11: clojure.lang.AFn.applyToHelper(AFn.java:163)
 12: clojure.lang.RestFn.applyTo(RestFn.java:133)
 13: clojure.core$apply.invoke(core.clj:540)
 14: clojure.core$pr_str.doInvoke(core.clj:3700)
 15: clojure.lang.RestFn.invoke(RestFn.java:409)

Suggested workaround:

(with-connection db
  (with-query-results res ["SELECT 1 FROM dual WHERE 0=0"]
    (not (empty? res))))

[CLJ-670] Add filter-indexed function

Thu, 6 Jan 2011 16:02:12 -0600

In Clojure 1.2, keep-indexed and map-indexed were introduced in lieu of promoting clojure.contrib.seq/indexed.

The difference between filter and keep is that keep treats false and nil differently; only nil values are removed. This behaviour may be desired in some places, but filter is much more common. It seems that since keep-indexed exists without filter-indexed, people might pull in the nil/false distinction where that's not appropriate.

I can provide a patch for this if desired.

[CLJ-463] Strip leading colons when creating keywords from single strings

Fri, 19 Nov 2010 10:07:07 -0600

This seems unfortunate:

=> (-> :foo str keyword)
::foo

Symbols are far saner in this regard:

=> (-> 'foo str symbol)
foo

Simply stripping leading colons from strings prior to turning them into keywords should suffice. The 2-arity Keyword.intern method and clojure.core/keyword fn should be left intact, so as to provide an escape hatch for those that really do need colon-prefixed keywords.

[CLJ-461] require namespace implicitly

Tue, 21 Jun 2011 18:41:38 -0500

Referencing a function with a fully-qualified namespace should work without first using require or use, similar to how a fully-qualified java class can be used without importing it.

It's a small change in Compiler that tries to call (require x) if the fully qualified classname is not found. This should give priority to the java class, which protects backwards compatibility. There is no runtime performance impact, only compile time (the first time the namespace is seen). The fact that code (the namespace) is loaded during compilation of a form is no different than loading code to look up a java class.

This makes it easier to write quick scripts as in the example below, also to use one-liners in the repl or ad hoc in code.

For example: java -cp src/clj/:classes clojure.main -e "(clojure.set/union #{1} #{2})"

Currently on master, this produces: Exception in thread "main" java.lang.ClassNotFoundException: clojure.set
but this works: java -cp src/clj/:classes clojure.main -e "(require 'clojure.set) (clojure.set/union #{1} #{2})"

Obviously, (use) would make the code shorter, but my goal is to make it implicit.

Discussion: http://groups.google.com/group/clojure-dev/t/69823ce63dd94a0c

[CLJ-455] Calculating large numbers results in java.math.BigIntegerArithmeticException

Sat, 23 Oct 2010 22:52:00 -0500

(class (* 1000 1000 1000 1000 1000 1000 1000))
1.1 returns : java.math.BigInteger
1.3.0-alpha returns : java.math.BigIntegerArithmeticException integer overflow clojure.lang.Numbers.throwIntOverflow (Numbers.java:1575)

[CLJ-452] Miscellaneous improvements to Clojure runtime usability from Java

Fri, 7 Oct 2011 12:22:43 -0500

Using Clojure from Java is very pleasant overall, but there are some rough edges, many of which could be smoothed over with very simple enhancements. I would suggest:

there should be an RT.var or Var.find that takes a single string
an IFn wrapper should be available that catches and rethrows Exceptions as RuntimeExceptions
a simple class (clojure.lang.Clojure perhaps?) that provides a well-documented and stable API for common operations: requiring namespaces, loading files, finding vars, evaluating strings, etc. This also would have a side benefit of allowing breaking changes to the implementation details without breaking interop code.

There are others of this sort that I've come across; will update the above as I remember them.

[CLJ-446] 1.3 alpha1 gives reflection warning in a case where 1.2 does not

Fri, 9 Dec 2011 15:20:10 -0600

Feel free to reclassify this as something other than a bug if I've misclassified it.

Related Clojure Google group conversation: http://groups.google.com/group/clojure/browse_thread/thread/83c08f6c2f313c50#

When doing AOT compilation on the attached program nbody.clj with 1.2:

java -Dclojure.compile.path=. -cp clojure-1.2.0.jar:. clojure.lang.Compile nbody

there are no reflection warnings, and a more complex version of the program using the type Body runs quickly. When doing AOT compilation with 1.3 alpha1:

java -Dclojure.compile.path=. -cp clojure-1.3.0-alpha1.jar:. clojure.lang.Compile nbody

I see these reflection warnings, and a more complex version of the program using the type Body runs significantly more slowly, most likely due to the reflection warned about:

Reflection warning, nbody.clj:18 - reference to field x can't be resolved.
Reflection warning, nbody.clj:19 - reference to field y can't be resolved.

Changing the name of the file to nbod.clj and the first line to "(ns nbod", and making corresponding changes to the compilation commands above, causes the reflection warnings to go away in 1.3 alpha1.

Similarly, taking the original attached file nbody.clj and replacing the three occurrences of "nbody" that are not the namespace name with a different name like "nbod" (or probably any name other than "nbody") also causes the reflection warnings to go away in 1.3 alpha1.

In case it makes any difference, I was using Clojure jars pulled via Leiningen, and HotSpot 1.6.0_xxx JVMs on Mac OS X 10.5.8 and Ubuntu 10.4.

Admittedly, a change with very limited impact on typical Clojure users. I wanted to file a ticket in case this was an unwanted consequence of some desirable change in 1.3.

[CLJ-436] Bug in clojure.contrib.json/read-json

Fri, 1 Oct 2010 15:32:00 -0500

What (small set of) steps will reproduce the problem?
$ java -cp lib/clojure-1.2.0.jar:lib/clojure-contrib-1.2.0.jar clojure.main
Clojure 1.2.0
user=> (require 'clojure.contrib.json)
nil
user=> (clojure.contrib.json/read-json "")
java.lang.IllegalArgumentException: Value out of range for char: -1 (NO_SOURCE_FILE:0)
user=>

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

Expected:

(if eof-error?
  (throw (EOFException. "JSON error (end-of-file)"))
  eof-value)

What version are you using?
1.2

Was this discussed on the group? If so, please provide a link to the discussion
[13:51] <na_ka_na> Hey guys I think there's a bug in clojure.contrib.json at line 116
[13:51] <na_ka_na> in clojure 1.2
[13:52] <na_ka_na> it has a (char i) and then checks for (= i -1) ... but (char -1) fails
[13:52] <na_ka_na> where can I report it ?
[13:53] <LauJensen> na_ka_na: assembla/support

[CLJ-419] LispReader uses Character.isWhitespace rather than Character.isSpaceChar

Sat, 23 Oct 2010 15:03:00 -0500

Character.isWhitespace doesn't handle non-breaking space correctly. Apparently it's pretty ancient from The Olden Days Before People Knew How To Do Character Encodings.

In Java 1.5 Character.isSpaceChar was added, which handles supplementary characters the right way: http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Character.html#isWhitespace(char)

[CLJ-414] In latest clojure, empty list is neither true nor false

Tue, 24 Aug 2010 00:35:00 -0500

In latest Clojure, compiled today:

user> (true? ())
false
user> (false? ())
false

This makes empty collections the only entities in Clojure which are neither true, nor false.
I'm fairly sure () used to be true – is this an intentional change? Googling reveals lots of warnings about the empty list not being false in Clojure.

[CLJ-412] clojure.xml/emit, emit-element are not documented at clojure.org

Tue, 24 Aug 2010 00:34:00 -0500

Neither function makes an appearance here:
http://clojure.github.com/clojure/clojure.xml-api.html
Despite the fact that neither appears to be private. Perhaps the doc generator just ignores all functions that have no doc comment?

[CLJ-411] clojure.xml/emit should be encoding-aware

Fri, 1 Oct 2010 09:56:00 -0500

clojure.xml/emit blithely asserts that it's writing UTF-8 despite the fact that it's actually writing characters, not bytes. Encoding isn't actually decided until actual bytes are written. This forces clients using clojure.xml/emit to write XML back to disk to use UTF-8. They won't know to do that unless they actually peek at the implementation. This behavior isn't documented.

(defn emit [x]
  (println "<?xml version='1.0' encoding='UTF-8'?>")
  (emit-element x))

[CLJ-410] clojure.xml parse/emit do not round-trip

Mon, 15 Nov 2010 12:49:00 -0600

I'm not expecting (emit (parse x)) to produce the same characters as originally in x. (That would be canonical form.)
However, it seems reasonable to expect that (= (parse x) (parse (emit (parse x)))). That's not currently the case because of #277 and #408.
It's not currently possible to demonstrate this bug via a unit test because of #409.
This fails:

(deftest parse-and-emit-should-round-trip-data
  (are [s0]
       (let [x1 (str->xml s0)
             s2 (xml->str x1)
             x3 (str->xml s2)]
         (is (= x1 x3)))
       "<e/>"
       "<e></e>"
       "<e>content</e>"
       "<e a='attribute'/>"
       "<e a='attribute'>content</e>"
       "<e><e><e/></e></e>"
       "<e> </e>"
       "<e>&lt;&amp;&gt;</e>"))
</code></pre>
Where:
<pre><code>(defn xml->str [x]
  (with-out-str
    (xml/emit-element x)))

(defn str->xml [s]
  (xml/parse
   (ByteArrayInputStream. (.getBytes s "UTF-8"))))

Or, rather it crashes prematurely in str->xml because of #409.

[CLJ-409] SAXParserFactoryImpl is missing at unit testing time

Tue, 24 Aug 2010 00:34:00 -0500

SAXParserFactoryImpl seems to be AWOL while clojure unit tests are running, but is present when clojure is started from the command line. WTF?

(ns clojure.test-clojure.clojure-xml
  (:use clojure.test)
  (:import [javax.xml.parsers SAXParserFactory])
  (:require [clojure.xml :as xml]))

(deftest sax-parser-factory-is-not-awol
  (is (SAXParserFactory/newInstance)))
</code></pre>
<pre><code>Tell ant to run the unit tests:

$ ant test

And get the following exception:

ERROR in (sax-parser-factory-is-not-awol) (SAXParserFactory.java:134)
expected: (SAXParserFactory/newInstance)
actual: javax.xml.parsers.FactoryConfigurationError: Provider
        org.apache.xerces.jaxp.SAXParserFactoryImpl not found
at javax.xml.parsers.SAXParserFactory.newInstance (SAXParserFactory.java:134)
   clojure.test_clojure.clojure_xml/fn (clojure_xml.clj:17)

Yet, when I run clojure from the command line and do the same thing,
all is well.

$ java -jar clojure.jar
Clojure 1.2.0-beta1
user=> (import 'javax.xml.parsers.SAXParserFactory)
javax.xml.parsers.SAXParserFactory
user=> (SAXParserFactory/newInstance)
#<SAXParserFactoryImpl org.apache.xerces.jaxp.SAXParserFactoryImpl@19381960>
user=>

[CLJ-408] clojure.xml emit does not properly escape attribute and element content

Mon, 15 Nov 2010 12:49:00 -0600

(with-out-str
  (clojure.xml/emit-element {:tag :e :attrs nil :content "&"}))
</code></pre>
produces: <e>&</e>
correct would be: <e>&amp;</e>
This is true for both element content and attribute content. < and > are not escaped as well. Furthermore, apostrophe ( ' ) in an attribute value leads to broken xml:
<pre><code>
<e a='''/>

[CLJ-406] Typo in underive causes breaking in the resulting hierarchy

Tue, 24 Aug 2010 18:31:00 -0500

There's a typo on line 4515 in core.clj, in the definition of underive:

{:parent ... }
; should be
{:parents ... }
</code></pre>
causing breakage in hierarchies which had relationships underived in them.

E.g.
<pre><code>
(derive ::foo ::bar)
(underive ::foo ::bar)
(derive ::foo ::bar)
; => NPE

#clojure discussion:

http://clojure-log.n01se.net/date/2010-07-21.html#20:54

[CLJ-395] "underive" corrupts ad hoc hierarchies.

Tue, 24 Aug 2010 11:06:00 -0500

See transcript below, from 1.20-dev snapshot compiled about a week ago:

user=> (derive ::dad ::grandad)
nil
user=> (derive ::son ::dad)
nil
user=> (underive ::dad ::grandad)
nil
user=> (derive ::dad ::grandad)
java.lang.NullPointerException (NO_SOURCE_FILE:0)
user=> (derive ::foo ::bar)
java.lang.NullPointerException (NO_SOURCE_FILE:0)
user=>

[CLJ-389] slurp should not read one character at a time

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

A discussion of slurp performance came up on the mailing list. The attached patch makes slurp use a 4kb buffer size instead of reading one character at a time, resulting in a significant performance improvement.

[CLJ-384] Document upgrade from 1.1 to 1.2

Fri, 1 Oct 2010 08:45:00 -0500

In addition to things I assume are bugs, I've hit a couple of issues going from 1.1 to 1.2

The change in meaning of the ^ reader macro is big

I'm seeing errors now that meta data is limited to String, Keyword, Symbol or Map (I had some boolean values as meta data in my framework).

There's the notes about how name collisions on imports are now warnings, not errors (I've also heard that may change back to errors as in 1.1).

What else?

Anyway, IMHO there needs to be a "Upgrade to 1.2" page on clojure.org

[CLJ-383] different arrities of macro don't work in 1.2 (20100607 build)

Tue, 24 Aug 2010 08:47:00 -0500

I've been in the process of upgrading my framework from 1.1 to 1.2 and I've hit a serious stopper in code that works (and was tested) under 1.1.

~/clojure-workspace/cascade
$ lein repl
cascade.version=> (use 'cascade)
nil
cascade.version=> (link nil nil nil)
java.lang.IllegalArgumentException: Wrong number of args (3) passed to: cascade$link (NO_SOURCE_FILE:1)
cascade.version=> (doc link)
-------------------------
cascade/link
([env function] [env function extra-path-info] [env function extra-path-info query-parameters])
Macro
  Creates a link to a view or action function. Additional path info data may be specified (as a seq of
  data items), as well as query parameters (as a map whose keys are strings or keywords and whose values
  are converted to strings.). Uses standard keys from the env map. The resulting link is returned as a string.
nil
cascade.version=> (.printStackTrace *e)
java.lang.IllegalArgumentException: Wrong number of args (3) passed to: cascade$link (NO_SOURCE_FILE:1)
 at clojure.lang.Compiler.eval(Compiler.java:5437)
 at clojure.lang.Compiler.eval(Compiler.java:5388)
 at clojure.core$eval.invoke(core.clj:2370)
 at clojure.main$repl$read_eval_print__5620.invoke(main.clj:183)
 at clojure.main$repl$fn__5625.invoke(main.clj:203)
 at clojure.main$repl.doInvoke(main.clj:203)
 at clojure.lang.RestFn.invoke(RestFn.java:422)
 at user$eval9$fn__10.invoke(NO_SOURCE_FILE:1)
 at user$eval9.invoke(NO_SOURCE_FILE:1)
 at clojure.lang.Compiler.eval(Compiler.java:5421)
 at clojure.lang.Compiler.eval(Compiler.java:5412)
 at clojure.lang.Compiler.eval(Compiler.java:5412)
 at clojure.lang.Compiler.eval(Compiler.java:5388)
 at clojure.core$eval.invoke(core.clj:2370)
 at clojure.main$eval_opt.invoke(main.clj:234)
 at clojure.main$initialize.invoke(main.clj:253)
 at clojure.main$null_opt.invoke(main.clj:278)
 at clojure.main$main.doInvoke(main.clj:353)
 at clojure.lang.RestFn.invoke(RestFn.java:422)
 at clojure.lang.Var.invoke(Var.java:369)
 at clojure.lang.AFn.applyToHelper(AFn.java:165)
 at clojure.lang.Var.applyTo(Var.java:482)
 at clojure.main.main(main.java:37)
Caused by: java.lang.IllegalArgumentException: Wrong number of args (3) passed to: cascade$link
 at clojure.lang.AFn.throwArity(AFn.java:439)
 at clojure.lang.AFn.invoke(AFn.java:47)
 at cascade$link.invoke(cascade.clj:90)
 at cascade$link.invoke(cascade.clj:92)
 at clojure.lang.Var.invoke(Var.java:381)
 at clojure.lang.AFn.applyToHelper(AFn.java:180)
 at clojure.lang.Var.applyTo(Var.java:482)
 at clojure.lang.Compiler.macroexpand1(Compiler.java:5283)
 at clojure.lang.Compiler.macroexpand(Compiler.java:5338)
 at clojure.lang.Compiler.eval(Compiler.java:5406)
 ... 22 more
Reflection warning, NO_SOURCE_PATH:6 - reference to field printStackTrace can't be resolved.
nil
cascade.version=> 
</code></pre>
 

Here's the source:

<pre><code>
(defmacro link
  "Creates a link to a view or action function. Additional path info data may be specified (as a seq of
  data items), as well as query parameters (as a map whose keys are strings or keywords and whose values
  are converted to strings.). Uses standard keys from the env map. The resulting link is returned as a string."
  ([env function]
    (link env function nil))
  ([env function extra-path-info]
    (link env function extra-path-info nil))
  ([env function extra-path-info query-parameters]
    `(link-path ~env (link-map-from-function ~function ~extra-path-info ~query-parameters))))

So, (doc) shows the number of parameters correctly, as does the code, but attempting to use it with 3 parameters generates the spurious error.

Here's a simpler example:

<pre>
<code>
$ lein repl
cascade.version=> (defmacro ex ([a] (ex a "no-b")) ([a b] `(format "a=%s, b=%s" ~a ~b)))
#'cascade.version/ex
cascade.version=> (ex)
java.lang.IllegalArgumentException: Wrong number of args (2) passed to: version$ex (NO_SOURCE_FILE:1)
cascade.version=> (ex 1)
java.lang.IllegalArgumentException: Wrong number of args (2) passed to: version$ex (NO_SOURCE_FILE:1)
cascade.version=> (ex 1 2)
"a=1, b=2"
cascade.version=>
</code>
</pre>

[CLJ-372] possible binding issue in clojure.template?

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

I came across some strange behavior the other day in clojure.test/are, where the template replacement seems a bit over-eager. As a simple case:

(use 'clojure.test)

(are [x y] (= x y)
'(4 9 16) (map (fn [x] (* x x)) '(2 3 4)))

gives "java.lang.Exception: Unsupported binding form: clojure.lang.LazySeq@7bed76a7", but

(are [x y] (= x y)
'(4 9 16) (map (fn [z] (* z z)) '(2 3 4)))

is fine. It seems that all instances of the variable x get replaced, even the ones in other expressions that are doing the replacing. A macroexpand-1 traced it to clojure.template, and if I patch apply-template there to use postwalk-replace rather than prewalk-replace, clojure.test/are works as I had expected. However, the simple test case I wrote to expose this problem (wrapping deftest around the first example above) fails with what seems to me to be a bizarre error:

[java] FAIL in (can-test-using-local-bindings) (test_clojure.clj:87)
[java] but got :pass
[java] expected: (= (quote (4 9 16)) (map (fn [x] (* x x)) (quote (2 3 4))))
[java] actual: (#<core$EQ clojure.core$EQ@a947850> (4 9 16) (4 9 16))

Can anyone decipher why this fails, or come up with a better solution?

[CLJ-371] dynamic defrecord definitions trumped by AOT versions in classpath

Fri, 2 Dec 2011 13:39:40 -0600

Symptom: Define a defrecord at the repl and you still see the old (AOT'd) defrecord.

In the attached project:
lein compile
lein repl

and enter the commands in the comment in src/defrecordissue/core.clj

Design Discussion here: http://dev.clojure.org/display/design/Dynamic+defrecord+definitions+trumped+by+AOT+versions+in+classpath

[CLJ-370] record multimethod

Sun, 16 Oct 2011 05:33:31 -0500

non-reflective dynamic creation of defrecord instances via a multimethod

[CLJ-363] defn doesn't put the right metadata on its fn value

Tue, 24 Aug 2010 08:20:00 -0500

duplicate of #270

user=> (defn foo {:bar :baz} [] 42)
#'user/foo
user=> (meta #'foo)
{:ns #<Namespace user>, :name foo, :file "NO_SOURCE_PATH", :line 221, :arglists ([]), :bar :baz}
user=> (meta foo)
{:ns #<Namespace user>, :name foo} ; the value has only the basic keys
user=> (defn foo {:lucy :ethel} [] 43)
#'user/foo
user=> (meta #'foo)
{:ns #<Namespace user>, :name foo, :file "NO_SOURCE_PATH", :line 224, :arglists ([]), :lucy :ethel}
user=> (meta foo) ; the value has the previous metadata
{:ns #<Namespace user>, :name foo, :file "NO_SOURCE_PATH", :line 221, :arglists ([]), :bar :baz}

[CLJ-351] Disable transients after persistent! call

Tue, 24 Aug 2010 08:10:00 -0500

Disable transients after persistent! call

[CLJ-345] clojure.contrib.string.replace-str throws NPE on nil string

Fri, 1 Oct 2010 06:44:00 -0500

Version: Clojure 1.2 / clojure-contrib 1.2

This call:

user=> (clojure.contrib.string/replace-str "a" "b" nil)
#<CompilerException java.lang.NullPointerException (NO_SOURCE_FILE:29)>

throws a NullPointerException when passed a nil string. It seems like more corner cases could be automatically handled by returning nil in this case rather than throwing an NPE. At the very least, it would be nice to update the docstring to state that s cannot be nil.

[CLJ-307] consistent deprecation strategy

Tue, 24 Aug 2010 10:39:00 -0500

I am filing this as a Clojure ticket even though the problem currently occurs mostly in Contrib. That's because I think there needs to be an official "Clojure way" – this ticket is a request for documentation, not implementation.

Absent official guidelines, function and namespace deprecation has been handled in an ad hoc fashion. Sometimes functions move from one namespace to another, leaving no trace. Other times, something is left in the old namespace: either an error or a warning redirecting to the new namespace.

I would like to see a recommendation that leaves some kind of visible trace (for at least one point release) both in the source code tree and in the api docs.

Fallback namespaces (http://groups.google.com/group/clojure-dev/browse_thread/thread/9fde83ce4c06ed77) are out of scope for this ticket, but might be a separate ticket that builds on whatever is decided here.

[CLJ-295] disambiguate protocol extended to two interfaces

Tue, 24 Aug 2010 10:32:00 -0500

If a protocol is extended to two interfaces, and an object implements both, it will get one of them at random. I'd be happy if this case was simply an error.

[CLJ-287] (take-nth 0 coll) spins wheels on Solaris

Tue, 24 Aug 2010 10:10:00 -0500

(take-nth 0 (range 5)) is a silly thing to do, but if you're anything like me then it inexorably fills heap space and cpu time by an infinite number of RMI calls.
I'm running Clojure 1.1.0-master-SNAPSHOT under Java 1.6R17 on Solaris 10 and I watched it fill up to 56GB
I think it should raise an exception instead but Im too new to clojure to recommend one. Sorry
Cheers
Simon

[CLJ-284] Cannot cast 0xFF to a byte (fails range check)

Tue, 28 Sep 2010 13:05:00 -0500

Prompted by a thread on the clojure group.

The recently added range checking to casts/coercions adversely affects a common usage of the byte cast to pull the 8 LSBs of an integer. Since the numerical representation of a byte is signed in java, the Byte.MIN_VALUE</code> and <code>Byte.MAX_VALUE</code> used in the range check of <code>clojure.lang.RT.byteCast() do not allow for integer values up to 0xFF.

[CLJ-283] recur ignores rest args

Tue, 24 Aug 2010 07:55:00 -0500

When you recur inside a function, the arguments are not assigned as expected:

(defn weird [& b]
(println b)
(when (< (first b) 2)
(recur (inc (first b)))))

(weird 1)

The first time it runs, b is a seq, but the second time it's just an integer.

After some discussion I found out this is because there's no way to apply recur, so technically making recur act as a normal function call means you can't pass a seq of args in. While this is arguably a decent workaround, it leads to very confusing, undocumented behaviour; at the very least it should be tracked in an issue until a better solution can be found.

[CLJ-271] Determine direct binding policy and controls

Tue, 24 Aug 2010 06:25:00 -0500

Direct binding is in place as an experiment. We need ways to control the application and granularity of direct binding.

[CLJ-261] Use Ant instead of Maven for Clojure-Contrib

Tue, 24 Aug 2010 06:19:00 -0500

It would be nice if we could go back to Ant for building the clojure-contrib. At this time, it appears to be downloading many different packages that are not a part of the Clojure-Contrib source but Maven dependencies. Furthermore, it would be consistent with the way that we currently build Clojure.

[CLJ-260] Cannot load clojure classes from Jar files outside classpath using URLClassLoader

Tue, 24 Aug 2010 15:18:00 -0500

It is not possible to use URLClassLoader to load a class from a jar file if the jar is outside the classpath. It seems that RT.load tries to search for *.clj file within the classpath and doesn't respect the URLClassLoader and then fails with:

Exception in thread "main" java.lang.ExceptionInInitializerError
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
at java.lang.Class.newInstance0(Class.java:355)
at java.lang.Class.newInstance(Class.java:308)
at Loader.main(Loader.java:17)
Caused by: java.io.FileNotFoundException: Could not locate net/experimentalworks/Foo__init.class or net/experimentalworks/Foo.clj on classpath:
at clojure.lang.RT.load(RT.java:402)
at clojure.lang.RT.load(RT.java:371)
at clojure.core$load_6449$fn_6458.invoke(core.clj:4171)
at clojure.core$load__6449.doInvoke(core.clj:4170)
at clojure.lang.RestFn.invoke(RestFn.java:413)
at clojure.lang.Var.invoke(Var.java:359)
at net.experimentalworks.Foo.<clinit>(Unknown Source)
... 7 more

The attached .tar.gz contains a sample jar file and the clojure file that was used to generate the class files as well as the sample loader. Java oder Scala written classes can be loaded without any problems. For sure the I put the clojure runtime into the classpath but not the loadme-clojure.jar

[CLJ-251] macroexpand should respect :inline

Fri, 7 Oct 2011 07:47:38 -0500

macroexpand and macroexpand-1 currently do not respect the :inline metadata of
functions. For example you currently see:

(macroexpand '(+ 1 2))
;=> (+ 1 2)

Instead, macroexpand should return something like:

;=> (. clojure.lang.Numbers (add 1 2))

...depending of course on the exact definition of +'s :inline fn.

[CLJ-241] Tests for reify

Tue, 24 Aug 2010 15:51:00 -0500

subsumed by #239 and #240

[CLJ-238] Make re-pattern accept multiple arguments to concatenate them.

Fri, 7 Oct 2011 07:51:41 -0500

This would help concatenating multiple regular expressions. The attached patch simply converts all arguments to a string and then pass that string to re-pattern. Currently if you're trying to concatenate literal regular expressions, you're force to use the str function. It's not much extra code, but given the similarity between re-pattern and str, I thought it would be nice to have them behave the same way. e.g.:

(re-pattern (apply str (map (partial format "%s{%s}") [\a \b \c \d \e] (iterate inc 1))))
would become
(apply re-pattern (map (partial format "%s{%s}") [\a \b \c \d \e] (iterate inc 1)))

It only save one call to str, so it might not warrant the extra code in the end.

[CLJ-237] Adding a :only-keys destructuring option, that throws an exception if there's extra key(s).

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

While discussing the issue that prompted ticket [[ticket:236]] on clojure-dev, Richard Newman suggested modifying map destructuring to incorporate a :only-keys. It works exactly like :keys but raises an exception if the destructured map contains other keys. The attached patch shows a possible implementation.

[CLJ-234] Adding provenance of deprecation warnings to the LispReader

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

The LispReader has some deprecation warnings, but they do not show their provenance. The attached patch provide improved warning messages by modifying the LineNumberingPushbackReader to include the source path of the file being read, so that it can be retrieved by the LispReader.

[CLJ-223] Maven build produces empty JAR

Tue, 24 Aug 2010 14:34:00 -0500

Currently, "ant" generates a valid pom.xml. but "mvn install" doesn't work – the target JAR is empty.

[CLJ-207] for macro does not allow :let clause in first position

Wed, 26 Dec 2012 05:13:49 -0600

I like to try and keep my level of nesting under control, and this
often involves hiding or re-structuring the let macro. The for macro
can implicitly assemble a let macro for you, but with a limitation
that the :let clause can't be first:

1:5 user=> (for [:let [z [:foo :bar]] x z] (name x))
java.lang.IllegalStateException: Can't pop empty vector (repl-1:5)
1:6 user=> (for [x [:foo :bar] :let [z (name x)]] z)
("foo" "bar")
1:7 user=>

Is this limitation intentional? Could the error message be improved?

Here's what I wanted to write:

(defn add-script-links-for-imported-javascript-libraries
       [env dom-nodes]
       (extend-dom dom-nodes [:html :head] :top
               (template-for [:let [aggregation (-> env :cascade :resource-aggregation)
                                         libraries (@aggregation :libraries)]
                                   asset-map libraries
                                   :let [path (to-asset-path env asset-map)]]
                       :script { :type "text/javascript" :src path } [ linebreak ])))

(the formatting is probably scrambled)

But I had to juggle it to this:

(defn add-script-links-for-imported-javascript-libraries
       [env dom-nodes]
       (let [aggregation (-> env :cascade :resource-aggregation)
              libraries (@aggregation :libraries)]
               (extend-dom dom-nodes [:html :head] :top
                       (template-for [asset-map libraries
                                           :let [path (to-asset-path env asset-map)]]
                               :script { :type "text/javascript" :src path } [ linebreak ]))))

Of course there are any number of ways to write this, but I prefer the
first option, as it does less of a job of obscuring what the main
point of the function is: a call to extend-dom.

[CLJ-199] chunked seqs support 'for' byte code can't be converted to dex for dalvik

Mon, 15 Nov 2010 12:49:00 -0600

Commit 306ef6 generates bytecode which can not be covered to dex for dalvik. See following git-bisect output for details.

306ef6d9e47253103ca0e5ae0f4b620d5fa2aeff is first bad commit
commit 306ef6d9e47253103ca0e5ae0f4b620d5fa2aeff (14316ae2110a779ffc8ac9c3da3f1c41852c4289)
Author: Chouser <chouser@n01se.net>
Date:   Sun Aug 23 21:36:41 2009 -0400

    Add support for chunked seqs to 'for'.  Refs #1

:040000 040000 d48a1b12db408d4bc5843367ea5529678522f57d 7d8717380716feab9ebc84883e60dceea8fb1e08 M src
:040000 040000 0d80fce85701005c13ce13c105524a4fff188396 5daece53b0dd2727dc7ffa9c0b773e7962de900d M test
bisect run success

processing clojure/core$generate_proxy__5911$iter__5947__5953$fn__5954$iter__5949__5956$fn__5957.class...

UNEXPECTED TOP-LEVEL EXCEPTION:
com.android.dx.cf.code.SimException: local variable type mismatch: attempt to set or access a value of type java.lang.Object using a local variable of type int. This is symptomatic of .class transformation tools that ignore local variable information.
 at com.android.dx.cf.code.BaseMachine.throwLocalMismatch(BaseMachine.java:537)
 at com.android.dx.cf.code.Simulator$SimVisitor.visitLocal(Simulator.java:504)
 at com.android.dx.cf.code.BytecodeArray.parseInstruction(BytecodeArray.java:472)
 at com.android.dx.cf.code.Simulator.simulate(Simulator.java:96)
 at com.android.dx.cf.code.Ropper.processBlock(Ropper.java:681)
 at com.android.dx.cf.code.Ropper.doit(Ropper.java:636)
 at com.android.dx.cf.code.Ropper.convert(Ropper.java:253)
 at com.android.dx.dex.cf.CfTranslator.processMethods(CfTranslator.java:252)
 at com.android.dx.dex.cf.CfTranslator.translate0(CfTranslator.java:131)
 at com.android.dx.dex.cf.CfTranslator.translate(CfTranslator.java:85)
 at com.android.dx.command.dexer.Main.processClass(Main.java:297)
 at com.android.dx.command.dexer.Main.processFileBytes(Main.java:276)
 at com.android.dx.command.dexer.Main.access$100(Main.java:56)
 at com.android.dx.command.dexer.Main$1.processFileBytes(Main.java:228)
 at com.android.dx.cf.direct.ClassPathOpener.processArchive(ClassPathOpener.java:245)
 at com.android.dx.cf.direct.ClassPathOpener.processOne(ClassPathOpener.java:130)
 at com.android.dx.cf.direct.ClassPathOpener.process(ClassPathOpener.java:108)
 at com.android.dx.command.dexer.Main.processOne(Main.java:245)
 at com.android.dx.command.dexer.Main.processAllFiles(Main.java:183)
 at com.android.dx.command.dexer.Main.run(Main.java:139)
 at com.android.dx.command.dexer.Main.main(Main.java:120)
 at com.android.dx.command.Main.main(Main.java:87)
...at bytecode offset 000000d7
locals[0000]: Lclojure/core$generate_proxy__5911$iter__5947__5953$fn__5954$iter__5949__5956$fn__5957;
locals[0001]: known-null
locals[0002]: known-null
locals[0003]: known-null
locals[0004]: known-null
locals[0005]: I
locals[0006]: Ljava/lang/Object;
stack[0003]: Lclojure/lang/IFn;
stack[0002]: Ljava/lang/Object;
stack[0001]: Ljava/lang/Object;
stack[top0]: known-null
...while working on block 00cd
...while working on method invoke:()Ljava/lang/Object;
...while processing invoke ()Ljava/lang/Object;
...while processing clojure/core$generate_proxy__5911$iter__5947__5953$fn__5954$iter__5949__5956$fn__5957.class

[CLJ-191] enhance stacktrace: causes like java, syntax like clojure

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

Various enhancements I'd like to make:
Copy the feature of java stacktrace to print "... 25 more" instead of duplicating stack lines.
Print java class.method in clojure format: class/method.

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

[CLJ-188] NPE when creating an empty array of ints, longs, floats or doubles [from #146 for 1.0]

Wed, 22 Sep 2010 23:27:00 -0500

NPE when creating an empty array of ints, longs, floats or doubles [from #146 for 1.0]

[CLJ-187] StringSeq implements Counted but doesn't provide a specialized impl for count() [for 1.0 from #186]

Wed, 22 Sep 2010 23:27:00 -0500

StringSeq implements Counted but doesn't provide a specialized impl for count() [for 1.0 from #186]

[CLJ-180] 1.0 bugfix: (namespace (symbol "/")) should return nil

Wed, 22 Sep 2010 16:27:00 -0500

Fix for master is valid for 1.0 too; see parent issue

[CLJ-176] structs printed with print-dup true cannot be read

Tue, 24 Aug 2010 06:14:00 -0500

(defstruct thing :a :b)
(def my-thing (struct thing 1 2))
(def s (binding [*print-dup* true] (pr-str my-thing)))
s 
;;=> "#=(clojure.lang.PersistentStructMap/create {:a 1, :b 2})"
(read-string s)
;;=> java.lang.IllegalArgumentException:
;;   No matching method found: create

[CLJ-161] *-zip lose metadata [for 1.0 from #134]

Fri, 1 Oct 2010 08:46:00 -0500

This ticket is for tracking #134 against branch 1.0

[CLJ-156] Classname/staticThing leaves Classname unresolved at syntaxQuote time [for 1.0 from #155]

Wed, 22 Sep 2010 14:27:00 -0500

Classname/staticThing leaves Classname unresolved at syntaxQuote time [for 1.0 from #155]

[CLJ-149] pop does not preserve meta-data

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

As discussed with chouser on irc.

Example:

=> (meta (conj (with-meta '(1 2 3) {:my :meta}) 4))
{:my :meta}
=> (meta (pop (with-meta '(1 2 3) {:my :meta}))) 
nil

Both calls should yield the same result.

This occurs in 1.0.0 as well as trunk.

This might be part of a larger issue with when meta-data should be preserved (e.g., butlast).

[CLJ-141] GC Issue 119: require doc out of date

Tue, 24 Aug 2010 03:51:00 -0500

This ticket is for tracking #123 against branch 1.0

[CLJ-132] Agents printed at the REPL do not always reflect their value

Tue, 24 Aug 2010 07:46:00 -0500

Starting with a fresh REPL and entering the following:

(def counter (agent 0))
(defn add1 [x] (inc x))
(send counter add1)
;; repeat many times
(send counter add1)

The representation printed at the REPL will not always display the correct value for the agent (e.g. the second call to `send` would print #<Agent@743fba: 1>). This appears to happen only in the first few calls to `send` before the value eventually "catches up". This behavior of course never occurs with `send-off`. This appears to only affect the printed value and not the actual value, but can still cause confusion.

My setup is as follows:
Mac OSX 10.5
Clojure 1.0.0
Running with `java -server -cp $CP jline.ConsoleRunner clojure.lang.Repl $*` where $CP points to clojure.jar, clojure-contrib.jar, and jline.jar

This also occurs with a fresh build of Clojure 1.1.0-alpha-SNAPSHOT from github.

-m

[CLJ-122] GC Issue 118: Patch to add :svn to clojure-version

Tue, 24 Aug 2010 06:45:00 -0500

Reported by miki.tebeka, May 16, 2009

Attached is a patch to add :svn to *clojure-version*.
In order for it to work do "svn ps svn:keywords Revision
src/clj/clojure/core.clj"

This way when people report problem in clojure, we can know the exact
revision they are talking about.

[CLJ-120] GC Issue 116: partition with pad

Fri, 2 Dec 2011 12:17:05 -0600

Reported by dimi...@gashinsky.com, May 09, 2009

;; A lot of times I needed a padding option on the partition. This is
;; my attempt to solve this problem. Any suggestions are welcome. I
;; hope this patch or something similar will make its way into the
;; core.

Some discussion that happened here:
http://groups.google.com/group/clojure/browse_frm/thread/6fcc1dd999a5ec02?tvc=1
was integrated into the patch.

[CLJ-118] GC Issue 114: version.properties in branch/1.0 is inaccurate

Fri, 20 Jul 2012 16:55:35 -0500

Reported by hlship, May 04, 2009

The version.properties in the 1.0 branch generates snapshot releases.
Ideally, there should be a tags/1.0 branch that locks down the 1.0 release.
Context: trying to build a 1.0 release artifact for the Maven repository.

Comment 1 by richhickey, May 04, 2009

Do you believe this advice was erroneous?

http://groups.google.com/group/clojure/msg/cb46994561dbc732

Comment 2 by hlship, May 05, 2009

I'm bothered that the 1.0 release is a 1.0 release, but not really.  Either its a
final release or its not. Saying its still a snapshot when you've broadcasted to the
world that its final seems very odd to me.

On the mailing list, I espoused the "Apache Way", which is to not get hung up on a
"1.0.0" number, but keep releasing.  If "1.0.2" has bugs, fix them and release
"1.0.3".  If that is finally stable, announce "Clojure 1.0 is version 1.0.3". Let the
release prove itself valid.

Older Tapestry releases were based on the "line in the sand" approach ... and always
ended up requiring a flurry of dot release bug fixes.

[CLJ-108] GC Issue 104: macro call from Java isn't evaluated

Tue, 24 Aug 2010 05:45:00 -0500

Reported by csaager, Apr 10, 2009

What (small set of) steps will reproduce the problem?
(defn abb [a [b] [& c]] b)
(defmacro extr [fun] `((meta (var ~fun)) :arglists))

Java 
Var extr,abb ...
Object arglists = extr.invoke(abb) 



What is the expected output? What do you see instead?
Expected ([a [b] [& c]]) (like in REPL)
Got: ((clojure.core/meta (var
#'org.enclojure.ide.nb.editor.ClojureSourceTemplate/abb)) :arglists) (a Cons)

What version are you using?
org-enclojure-ide-nb-editor-20090406.590.1337.nbm

Was this discussed on the group? If so, please provide a link to the
discussion:

Please provide any additional information below.

I tried to call Compiler.eval(arglists) and eval.invoke(arglists), both
threw an exception
Exception in thread "main" java.lang.ClassCastException: clojure.lang.Var
cannot be cast to clojure.lang.Symbol (NO_SOURCE_FILE:0)
        at clojure.lang.Compiler.analyzeSeq(Compiler.java:4493)
        at clojure.lang.Compiler.analyze(Compiler.java:4315)
        at clojure.lang.Compiler.analyze(Compiler.java:4276)
        at clojure.lang.Compiler$InvokeExpr.parse(Compiler.java:2761)
        at clojure.lang.Compiler.analyzeSeq(Compiler.java:4488)
        at clojure.lang.Compiler.analyze(Compiler.java:4315)
        at clojure.lang.Compiler.analyze(Compiler.java:4276)
        at clojure.lang.Compiler$InvokeExpr.parse(Compiler.java:2757)
        at clojure.lang.Compiler.analyzeSeq(Compiler.java:4488)
        at clojure.lang.Compiler.analyze(Compiler.java:4315)
        at clojure.lang.Compiler.analyze(Compiler.java:4276)
        at clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:3852)
        at clojure.lang.Compiler$FnMethod.parse(Compiler.java:3687)
        at clojure.lang.Compiler$FnMethod.access$1100(Compiler.java:3564)
        at clojure.lang.Compiler$FnExpr.parse(Compiler.java:2953)
        at clojure.lang.Compiler.analyzeSeq(Compiler.java:4484)
        at clojure.lang.Compiler.analyze(Compiler.java:4315)
        at clojure.lang.Compiler.eval(Compiler.java:4520)
        at clojure.core$eval__3975.invoke(core.clj:1743)
        at clojure.lang.Var.invoke(Var.java:346)
        at com.yourcompany.NewClass.main(NewClass.java:32)
Caused by: java.lang.ClassCastException: clojure.lang.Var cannot be cast to
clojure.lang.Symbol
        at clojure.lang.Compiler$TheVarExpr$Parser.parse(Compiler.java:485)
        at clojure.lang.Compiler.analyzeSeq(Compiler.java:4486)
        ... 20 more



Comment 1 by durka42, Apr 12, 2009

I am not sure this is a bug.

Macros are just functions with a bit set in the metadata, so when called like
functions they should just return code.
extr.invoke(abb) returns ((clojure.core/meta (var #'clojure.core/abb)) :arglists).
Note that the macro was called with the Var abb. When evaluated, this throws an
exception because var was called with a Var instead of a symbol (it is meant to be
called as (var abb)).
What the REPL does is more like extr.invoke(RT.readString("abb")) or
extr.invoke(Symbol.create("abb")), both of which return ((clojure.core/meta (var
abb)) :arglists) which can be evaluated as you expect.

Comment 2  by richhickey, Apr 12, 2009

Please discuss things like this on the group to clarify the issue and your
understanding before posting an issue here - thanks.

Status: Invalid

[CLJ-101] GC Issue 97: partition-by does not work correctly when passed a function with side-effects

Tue, 24 Aug 2010 04:45:00 -0500

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

(def coll '(a a b c nil nil nil d e f))
(partition-by #(or (nil? %) (gensym)) coll)
==> partition-by runs into an endless loop


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

From what the doc string says it seems that
partition-by would return:
((a) (a) (a) (b) (c) (nil nil nil) (d) (e) (f))
The provided function returns for non-nil elements
a new value.


> What version are you using?

r1327


> Please provide any additional information below.

A minimum change would be to update the doc strings,
stating that f must not have side-effects.
But if we would like to keep that door open, then the
current behaviour could be patched.
The problem is this:
In partition-by fv gets assigned (f (first s)), and
only a moment later (f (first s)) is evaluated again,
in the binding for run, in the take-while.
But as f has side effects we have:
(= (f (first s)) (f (first s))) ==> false
Now take-while will return an empty lazy-seq and the
drop will remove zero elements, as run is empty.

Instead fv should always be an element of run, and
take-while should run on the rest of s instead of on
s itself.

Comment 1  by richhickey, Mar 16, 2009

partition-by is not part of Clojure core

Status: Invalid

[CLJ-100] GC Issue 96: In FOR macro the :let clause does not establish a lexical binding

Tue, 24 Aug 2010 00:45:00 -0500

Reported by splendidlord, Mar 14, 2009

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

In a fresh Clojure:
(for [a (range 5) :let [x (* a a)]] x)
==> java.lang.Exception: Unable to resolve symbol: x in this context

Now:
(def x -1000)
(for [a (range 5) :let [x (* a a)]] x)
==> (-1000 -1000 -1000 -1000 -1000)


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

It should be:
(for [a (range 5) :let [x (* a a)]] x)
==> (0 1 4 9 16)


> What version are you using?

SVN r1327

Comment 1 by splendidlord, Mar 14, 2009

Sorry, I have two clojure.jars on my system and I used an older one.
In r1327 this bug does not longer exist. Please close the issue, thanks.

Comment 2 by richhickey, Mar 16, 2009

(No comment was entered for this change.)

Status: Invalid

[CLJ-89] GC Issue 85: In a defn, arglists metadata becomes the first (unexpected?) symbol

Tue, 24 Aug 2010 03:45:00 -0500

Reported by jochu0, Feb 22, 2009

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

(:arglists (meta (defn arglists broken-arglist ([a] a) ([a b] b))))
(broken-arglist)

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

I would expect ([a] [a b]) if not an error.

> What version are you using?

Using the latest clojure (r1298) and also likely to exist before lazy-seq.

> Was this discussed on the group? If so, please provide a link to the
discussion:

http://groups.google.com/group/clojure/browse_thread/thread/bafdb169330a9344

[CLJ-85] Double post of #84

Tue, 24 Aug 2010 00:45:00 -0500

Double post of #84

[CLJ-82] GC Issue 79: Allow read to accept readers other than a PushbackReader

Tue, 24 Aug 2010 00:45:00 -0500

Reported by p...@hagelb.org, Feb 12, 2009

"read" should be able to accept different kinds of readers, wrapping them
in a PushbackReader where necessary.

This should be implemented in LispReader.java rather than the read function
in core.clj, since the latter would require turning read into a multimethod.

http://groups.google.com/group/clojure/browse_thread/thread/fedbb2a63af633f0


Comment 1 by p...@hagelb.org, Feb 12, 2009

Attached a small patch that provides this and updates the docstring for read.

Simple test case: (= [1 2 3] (read (java.io.StringReader. "[1 2 3]")))

Comment 2  by p...@hagelb.org, Feb 20, 2009

Feel free to close this out as a wontfix; I can't find any way around the problems
brought up by the mailing list.

Comment 3 by richhickey, Feb 21, 2009

ok - WontFix

Status: WontFix

[CLJ-72] GC Issue 69: Documentation: repl_and_main page should discuss use of java -jar clojure.jar

Tue, 24 Aug 2010 04:45:00 -0500

Reported by hlship, Feb 08, 2009

In many cases, when you have a script with no extra dependencies outside of
Clojure, it is easiest to:

java -jar clojure.jar myscript.clj

This should be mentioned on:

http://clojure.org/repl_and_main

Comment 1 by richhickey, Feb 09, 2009

This was discussed and it was agreed that this causes more problems later on for new
users when try to use other jars and -cp doesn't work

Status: WontFix

[CLJ-61] GC Issue 57: Compiler internal error when expanding macro: class not found

Tue, 24 Aug 2010 03:44:00 -0500

Reported by tuomas.lukka, Jan 29, 2009
 
------------------------------

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

Run the following code:

(defmacro b [] (let [ x (fn [] []) ] x))
(def a (fn [] (b)))


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

I'd expect it to either pass or give a proper error. What I get
is

Exception in thread "main" java.lang.ExceptionInInitializerError (test.clj:2)
 at clojure.lang.Compiler$DefExpr.eval(Compiler.java:308)
 at clojure.lang.Compiler.eval(Compiler.java:4147)
 at clojure.lang.Compiler.load(Compiler.java:4470)
 at clojure.lang.Compiler.loadFile(Compiler.java:4437)
 at clojure.lang.Script.main(Script.java:65)
Caused by: java.lang.ExceptionInInitializerError
 at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
 at
sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
 at
sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
 at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
 at java.lang.Class.newInstance0(Class.java:355)
 at java.lang.Class.newInstance(Class.java:308)
 at clojure.lang.Compiler$FnExpr.eval(Compiler.java:3218)
 at clojure.lang.Compiler$DefExpr.eval(Compiler.java:297)
 ... 4 more
Caused by: java.lang.RuntimeException: java.lang.ClassNotFoundException:
clojure.core$b__1$x__3
 at clojure.lang.RT.readString(RT.java:1192)
 at clojure.core$a__7.<clinit>(test.clj:2)
 ... 12 more
Caused by: java.lang.ClassNotFoundException: clojure.core$b__1$x__3
 at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
 at java.security.AccessController.doPrivileged(Native Method)
 at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
 at clojure.lang.DynamicClassLoader.findClass(DynamicClassLoader.java:52)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
 at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
 at java.lang.Class.forName0(Native Method)
 at java.lang.Class.forName(Class.java:247)
 at clojure.lang.RT.classForName(RT.java:1506)
 at clojure.lang.LispReader$EvalReader.invoke(LispReader.java:908)
 at clojure.lang.LispReader$DispatchReader.invoke(LispReader.java:530)
 at clojure.lang.LispReader.read(LispReader.java:143)
 at clojure.lang.RT.readString(RT.java:1188)
 ... 13 more


What version are you using?

20081217

Was this discussed on the group? If so, please provide a link to the
discussion:

no

[CLJ-50] GC Issue 46: callable defstruct (PersistentStructMap$Def extends AFn)

Mon, 15 Nov 2010 08:14:04 -0600

Reported by chouser, Jan 15, 2009
Describe the feature/change.

This much works already:
(defstruct rect :width :height)
(struct rect 5 10)  ==> {:width 5, :height 10}

With the included patch you can also:
(rect 5 10)  ==> {:width 5, :height 10}

Was this discussed on the group? If so, please provide a link to the
discussion:

http://groups.google.com/group/clojure/browse_thread/thread/12a138ad58ff6c36/b20b68ef939fccf7

Comment 1 by chouser, Jan 15, 2009
Forgot the patch attachment.
 structmap-def-extends-restfn.patch
923 bytes Download

[CLJ-39] GC Issue 35: Wiki is closed to the public

Tue, 24 Aug 2010 03:44:00 -0500

Reported by dresweng...@dreish.org, Jan 07, 2009
Last night on IRC, the GC Wiki was suggested as a way to organize a users'
wish-list so rhickey can conveniently ignore it and focus on real issues in
the issue tracker.  Unfortunately, it appears only rhickey is allowed to
edit, much less add pages to, the wiki.

Comment 1 by richhickey, Jan 07, 2009
No, the suggestion was to use the user wiki:

http://en.wikibooks.org/wiki/Clojure_Programming
Status: WontFix

[CLJ-17] GC Issue 13: validate in (keyword s) and (symbol s)

Fri, 7 Oct 2011 08:03:06 -0500

Reported by richhickey, Dec 17, 2008
Make sure they create readable keywords/symbols

Comment 1 by p...@hagelb.org, Apr 27, 2009
Could this be done with a regex, or should it try to confirm the name using the reader?
Comment 2 by p...@hagelb.org, Apr 27, 2009
I've implemented this in the attached patch. One thing that could be improved is that
invalid names simply raise an Exception, though it seems LispReader's ReaderException
would be more appropriate. I wasn't sure how to raise that though since it needs a
line number; it's not clear how to get the current line number.

The patch is still an improvement on the current state of things, though I'd
appreciate a tip as to how to raise the right exception.

I've also attached a patch to the test suite that ensures (symbol s) and (keyword s)
work properly in the context of invalid names. I can re-submit this to the contrib
project if that's desired if the core patch is accepted.
 0001-Test-invalid-symbol-keyword-names-raise-exceptions.patch
1.6 KB Download
Comment 3 by p...@hagelb.org, Apr 27, 2009
Last patch had a problem; used things like defn- etc. before they were defined in
core.clj. This attachment fixes that.
 validate-symbol-keyword-names.patch
2.1 KB Download
Comment 4 by p...@hagelb.org, Jun 13 (3 days ago)
This exists as a git branch too now: 
http://github.com/technomancy/clojure/tree/validate-symbols-issue-13

[CLJ-4] test ticket 2

Tue, 24 Aug 2010 11:44:00 -0500

a second test ticket

[CLJ-3] Test ticket

Tue, 24 Aug 2010 11:44:00 -0500

this is a test ticket

Clojure JIRA

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

[CLJ-1194] Typo in core.reducers

[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-1170] conj-ing x on equal values should produce equal results

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

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

[CLJ-1089] clojure.java.io/copy interprets read count of 0 as eos

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

[CLJ-1054] Syntax quoted form produces a sequence, not a list

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

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

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

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

[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-1014] Latest Clojure master doesn't build

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

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

[CLJ-984] Expose minKey and maxKey on PersistentTreeSet

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

[CLJ-967] java.io/do-copy can still garble multibyte characters on IBM JDK 1.5 and 1.6

[CLJ-956] [java.lang.ClassFormatError: Duplicate method name&signature] when using gen-class

[CLJ-951] Clojure 1.3+ can't intern a dynamic var

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

[CLJ-945] clojure.string/capitalize can give wrong result if first char is supplementary

[CLJ-926] Instant literals do not round trip correctly

[CLJ-922] Transient maps lose values

[CLJ-913] slurp fails on /proc files (linux)

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

[CLJ-907] records do not enforce type hints

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

[CLJ-901] implementation of doc macro in core.repl incorrect for special names... add one character to fix

[CLJ-894] Better reduce performance

[CLJ-883] Clojure head holding bug

[CLJ-877] contains? is broken for vectors

[CLJ-875] Clojure's seq, keys, and vals can produce inconsistent values on strange iterators (e.g., IdentityHashMap)

[CLJ-869] Macro auto-gensym in let not visible after a nested unquote/syntax-quote

[CLJ-851] Type-hinting a var with primitive array pseudo-class results in IllegalArgumentException when the var is used as an arg

[CLJ-848] defn :or form does not warn you if you provide a vector instead of a map

[CLJ-841] Unable to download clojure using wget. Wget seems to be blocked...

[CLJ-826] Include drop, take, butlast from clojure.contrib.string (1.2) in clojure.string 1.3

[CLJ-820] int coercion doesn't work in clojure 1.3

[CLJ-819] deftype print/read doesn't munge field names

[CLJ-818] doc string for resolve mentions &env

[CLJ-814] Make the #= reader macro an official" part of the language

[CLJ-810] clojure.set/difference

[CLJ-804] Expose memoization cache and original as metadata on memoized functions.

[CLJ-799] ArrayMaps print-dup with read-eval

[CLJ-793] print-doc triggers NPE in clojure.lang.Namespace.find

[CLJ-785] Optimize /

[CLJ-767] Remove support for non-primitive bit-shift operations

[CLJ-762] Clojure compilation hangs

[CLJ-758] Add Clojure program to generate HTML and LaTeX cheatsheets from common source

[CLJ-756] Workable upload destination for release zips

[CLJ-746] Unreference keywords not correctly removed from keyword table (Utils.clearCache)

[CLJ-744] proxy hides protected final methods

[CLJ-743] Error messages for invalid destructured bindings are not helpful

[CLJ-732] (keyword "") can be printed, but not read

[CLJ-725] (;) causes repl to hang in Clojure 1.3-0-alpha3 on Mac OS X 10.6.3 Intel

[CLJ-724] bean throws NPE when key doesn't exist

[CLJ-723] Add def- macro to core

[CLJ-722] Misleading documentation string in doseq

[CLJ-717] A range function for characters, char-range

[CLJ-714] Real multi-line comments

[CLJ-709] Add a way to test/detect promise objects

[CLJ-707] -> produces known-invalid code when it could be smarter

[CLJ-694] Set func create sorted hash-set

[CLJ-692] Should "some" be using "seq?" rather than "seq" ?

[CLJ-688] subs function should count back from the end of the string when given negative offset

[CLJ-676] Calling seq on the resultset-seq of an empty ResultSet throws an exception

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

[CLJ-176] structs printed with print-dup true cannot be read

[CLJ-122] GC Issue 118: Patch to add :svn to clojure-version