Clojure JIRA

[TMACRO-2] protect let-bound symbols from macrolet expansion

Tue, 27 Nov 2012 08:41:28 -0600

As discussed here: https://groups.google.com/d/msg/clojure-dev/-/UheAzkyI_WcJ

Patch macrolet-protect.diff fixes the issue and provides a test.

[MTOWER-1] README should be updated to conform to contrib standard

Mon, 17 Sep 2012 11:33:44 -0500

As per Sean Corfield's suggestion here: https://groups.google.com/forum/?fromgroups=#!searchin/clojure-dev/math/clojure-dev/p5oz42gR_sk/cesMHO9cDWEJ
the math.numeric-tower README.md should be updated to be more useful, especially to newbies.

[MCOMB-1] math.combinatorics README should be updated to conform to contrib standard

Mon, 17 Sep 2012 11:35:57 -0500

As per Sean Corfield's suggestion here: https://groups.google.com/forum/?fromgroups=#!searchin/clojure-dev/math/clojure-dev/p5oz42gR_sk/cesMHO9cDWEJ
the math.combinatorics README.md should be updated to be more useful, especially to newbies.

[LOGIC-64] Support inequalities in finite domain sugar

Sat, 27 Oct 2012 11:33:23 -0500

The attached patch enables the follow code:

(run* [x]
  (infd x (interval 0 9))
  (eqfd (!= 6 (* 2 x))))

You can also substitute != with <, >, >=, or <=

[LOGIC-44] ex* could expand macros in patterns

Sun, 17 Mar 2013 19:05:17 -0500

So, tagged data structures are probably interesting in a relational context. Say you have a relation with some default logic about dogs:

(defna friendlyo [Dog-Or-Breed]
    ([:Spot] succeed)
    ([:Spike] fail)
    ([Other-Dog] (fresh [Breed] (dog-breed Other-Dog Breed) (friendlyo Breed)))
    ([(breed :miniature-dachshund)] fail)
    ([(breed :golden-retriever)] succeed)
    ;. . .)

Assume there's a (defmacro breed [t] `[:breed ~t]).

That's nicer than having to drop [:breed :golden-retriever] in there or whatever, since it's compile-time-checkable, less error-prone, reduces duplication, etc.

This little patch makes ex* expand macros in patterns so it doesn't treat e.g. (breed :golden-retriever) as introducing a new LVar called "breed". Test also provided.

[CLJS-485] clojure.string/replace ignores regex flags

Tue, 12 Mar 2013 10:36:36 -0500

The replace function in namespace clojure.string ignores regex flag provided in the match pattern. For example:

CLJS

clojure.string/replace "I am NOT matched" #"(?i)not " "")
=> "I am NOT matched"

CLJ

clojure.string/replace "I am NOT matched" #"(?i)not " "")
=> "I am matched"

The attached patch fixes this by parsing the m and i flags, if set, from the match object, instead of explicitly setting only "g".

[CLJS-441] Require implicit 'do nodes for all blocks in AST

Fri, 21 Dec 2012 17:36:42 -0600

Discussion here: https://groups.google.com/d/topic/clojure-dev/6CVTsW1EQn4/discussion

[CLJS-440] Replace :is-loop flag in AST with distinct :loop op

Fri, 21 Dec 2012 17:12:07 -0600

Discussion here: https://groups.google.com/d/topic/clojure-dev/6CVTsW1EQn4/discussion

[CLJS-437] Missing "Too few arguments to if" check

Fri, 7 Dec 2012 00:03:55 -0600

(if) and (if 1) both return nil. JVM clojure throws "Too few arguments to if".

[CLJS-432] Include line and file information in error messages

Fri, 30 Nov 2012 11:25:39 -0600

Just as the ana/warning function did, now errors and assertions include line and file source information. I needed this sorely.

[CLJS-431] namespace and name fail on '/

Fri, 30 Nov 2012 11:56:54 -0600

Both the 'namespace and the 'name functions use .lastIndexOf to search for "/". This fails on the division symbol if you don't provide a starting index to search from.

[CLJS-426] subvec function not behaving consitently with invalid subranges

Fri, 23 Nov 2012 15:25:10 -0600

When using the subvec function with a as a parameter vector and a range that is not in the original vector, the function returns a value:

(subvec [1 2 3] 0 4) => [1 2 3 nil]

However, when using with seqs, it works as it supposed to:

(subvec (range 3) 0 4) => ERROR: Index out of bounds

This is because the validation of ranges is not happening at build time of the subvec type, this bug contains a patch that adds a new private `build-subvec` function into cljs.core.

[CLJS-424] Internal representation of keywords can not be differentiated by printable characters

Sat, 22 Dec 2012 15:45:34 -0600

Currently, Symbols are represented by (str \uFDD1 \' name) and keywords are represented by (str \uFDD0 \' name)

The \uFDDX character is not printable, so it appears as a little box when printed in a javascript repl such as the browser's console. The following character is always a \' regardless of whether the object is a symbol or a keyword. This has bitten me during debugging on several occasions. The attached patch changes keywords to be represented internally by (str \uFFD1 \: name)

[CLJS-416] emit-block doesn't use context argument

Fri, 21 Dec 2012 17:30:54 -0600

emit-block currently has arguments [context statements ret] but the context argument is never used and all call sites always draw statements and ret from the same block AST node. The attach patch simplifies emit-block and all call sites to use arguments [{:keys [statement ret]}]

[CLJS-409] Small code cleanup for emitting goog.provide statements

Sat, 27 Oct 2012 16:52:59 -0500

Just abstracts out a duplicated piece of code.

[CLJS-408] Include :form on fn :methods in AST

Sat, 27 Oct 2012 16:52:42 -0500

All core CLJS AST nodes include a :form key. Several quasi-nodes similarly include their originating code forms. Although :fn nodes include their :form, it varies between single and multiple arity functions. I've found it easier to assume multiple arities and always analyze :methods directly. Unfortunately, the methods lack :form keys. This simple patch exposes the form of each method, simplifying function transformations.

[CLJS-398] new macro cljs.core/extend-instance

Fri, 19 Oct 2012 19:51:02 -0500

Patch introduces an extend-instance macro, similar to extend-type.
It doesn't extend the .prototype property, but assigns the prototype impl members to the instance itself.

This is useful to let existing instances, e.g. parsed JSON directly implement a protocol.

[CLJS-397] Omit var reads in statement context

Tue, 23 Oct 2012 18:49:53 -0500

Attached patch updates cljs emitter to not emit var references in statement context.
That causes toplevel deftypes to not return their generated type, which lets gclosure strip them if unused

cljs helloworld shrinks from ~90K to ~69K

https://groups.google.com/d/topic/clojure/LNfJRw07u8I/discussion

[CLJS-394] PersistentTreeSet lookup bug

Mon, 15 Oct 2012 22:02:51 -0500

The lookup function in PersistentTreeSet behaves differently in clojurescript than in clojure when a custom comparison function is used. If two elements are evaluated as equal, one of then is in the set and we do a lookup on the other, clojure returns the element in the set, whereas clojurescript returns the lookup element.

(let [compare-quot-2 #(compare (quot %1 2) (quot %2 2))
s (sorted-set-by compare-quot-2 1)]
(get s 0))

Should return: 1
Returns: 0

[CLJS-370] Incorrect behavior of integer? for integral floating point expressions

Wed, 5 Sep 2012 11:40:48 -0500

This includes infinity, exponential expressions, etc.

See: http://stackoverflow.com/questions/3885817/how-to-check-if-a-number-is-float-or-integer

[CLJS-369] gensyms break re-analyze; prevents variable shadowing analysis

Wed, 17 Oct 2012 10:53:50 -0500

From my email discussion with dnolon before making this patch:

The current analyzer does some trickery to prepare for emitting to JavaScript. Among this trickery is gensyms for locals (including "this"), the new $ prefix on some namespaces, uniqify on parameters, and more. This must be mildly annoying for people writing alternate compiler backends, but for the most part non-blocking because fewer symbol collisions should never be an additional problem for a target language with different symbol resolution rules.

[snip lots more text]

Consider what an ANF transform would look like for the :let form:

(defmethod anf :let
  [{:keys [env bindings statements ret form] :as ast}]
  (let [bindings (mapcat (fn [{:keys [sym init] :as binding}]
                           [name (anf init)])
                         bindings)
        body-env (-> bindings last :env)]
    (ana/analyze env `(~(first form) [~@(map :form bindings)]
                          ~@(anf-block (assoc ast :env body-env))))))

Simple enough, right? This walks each binding, ANF transforms the init expression, gets the environment in which to analyze the body, and then analyzes a new let (or loop) statement with the modified bindings.

Unfortunately, this doesn't work. When the ana/analyze call happens, body-env contains gensymed locals. The result is that body-env is invalidated by the outer analyze call, which is re-generating the symbols for the local variables. If you take the gensyms out of analyze-let, then analyze becomes pure (modulo def forms) and this code magically becomes correct. I've run into this same problem anywhere gensyms are used in analyze.

Commit message on the patch:

AST Changes
    
    * Anywhere a binding was introduced for a local used to be a symbol,
      now it is a map with a :name key and potentially a :shadow key.
    
    * Bindings vectors are no longer alternating symbols, then init maps.
      Instead, the are a vector of maps of the shape described for locals
      plus an :init key.
    
    * The :gthis key for functions has been replaced with :type, which
      is the symbol describing the type name of the enclosing deftype form.
    
    * recur frames now expose :params as binding maps, instead of :names
    
    Benefits:
    
    * Shadowed variables are now visible to downstream AST transforms.
    
    * :tag, :mutable, and other metadata are now uniform across ops
    
    * Eliminates usages of gensym inside the analyzer, which was a source
      of state that made the analyzer impossible to use for some
      transformations of let, letfn, etc which require re-analyzing forms.
    
    * Removes JavaScript shadowing semantics from the analyze phase.

[CLJS-360] Analyzer incorrectly merges metadata when redefining vars

Fri, 31 Aug 2012 11:29:48 -0500

I'm experimenting with using the analyzer for some more sophisticated macros, including a CPS transform and control constructs. During interactive development, I discovered that the analyzer is incorrectly merging metadata on vars when redefining them. This patch changes redef's to replace, rather than merge, existing var metadata.

The patch does not include a test, since the tests don't currently muck with the analyzer directly. Here's some code you can play with in your repl:

(require '[cljs.analyzer :as ana])
(require '[cljs.compiler :as comp])

(def env (ana/empty-env))

(defn show-foo [form]
  (ana/analyze env form)
  (-> @ana/namespaces (get 'cljs.user) :defs (get 'x) :foo))

(show-foo '(def ^{:foo 1} x 1))

(show-foo '(def ^{:foo 2} x 1))

(show-foo '(def x 1))  ; before patch, this returns 2. After patch, nil.

[CLJS-326] hash-set and PersistentHashSet/fromArray == faster set construction

Mon, 25 Jun 2012 06:33:47 -0500

As discussed with mmarczyk in irc, the attached patch implements Clojure's hash-set function and modifies the compiler to create sets using a new fromArray static method. To test these, I created three new benchmarks. Here's before and after benchmark results:

$ time ./script/benchmark | grep '#{'
[], #{}, 100000 runs, 77 msecs
[], #{1 2 3}, 100000 runs, 582 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 104 msecs
[], #{}, 100000 runs, 740 msecs
[], #{1 2 3}, 100000 runs, 1809 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 221 msecs
[], #{}, 100000 runs, 281 msecs
[], #{1 2 3}, 100000 runs, 1310 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 288 msecs
./script/benchmark 109.41s user 3.82s system 127% cpu 1:28.96 total

$ time ./script/benchmark | grep '#{'
[], #{}, 100000 runs, 1 msecs
[], #{1 2 3}, 100000 runs, 333 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 100 msecs
[], #{}, 100000 runs, 1 msecs
[], #{1 2 3}, 100000 runs, 1670 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 325 msecs
[], #{}, 100000 runs, 1 msecs
[], #{1 2 3}, 100000 runs, 689 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 321 msecs
./script/benchmark 103.94s user 4.89s system 108% cpu 1:39.88 total
grep '#{' 0.00s user 0.00s system 0% cpu 1:39.85 total

[CLJS-321] Support with-out-str

Mon, 22 Oct 2012 18:06:13 -0500

Attached patch implements with-out-str macro in terms of goog.string.StringBuffer and print-fn via .append

The attached patch also fixes ~~CLJS-319~~

[CLJS-320] memfn not supported

Mon, 18 Jun 2012 21:01:52 -0500

The docs say "it almost always preferable to do this directly now", but this was one more thing that slowed down the porting of a small piece of JVM Clojure code for me. I'm of the opinion that parity with Clojure proper is desirable where it doesn't hurt platform interop or performance.

[CLJS-319] missing spaces when printing the same thing more than once

Thu, 5 Jul 2012 15:06:57 -0500

E.g. (println 1 1) prints "11\n" instead of "1 1\n".

Here's the culprit:
https://github.com/clojure/clojurescript/blob/master/src/cljs/cljs/core.cljs#L6136-6137

[CLJS-304] Comparing a js/Date to nil throws

Mon, 18 Jun 2012 20:59:50 -0500

(= (js/Date.) nil)

[CLJS-301] Inline instance?

Sat, 22 Dec 2012 16:33:35 -0600

See discussion on http://dev.clojure.org/jira/browse/CLJS-300

This is a low priority patch for inlining instanceof checks. I don't know if it has any significant performance improvement, but the patch was sort of a side effect of my work on ~~CLJS-300~~, so I figured I'd bundle it up and share it here in case someone wants to test it's perf impact and apply if it is a win.

[CLJS-300] RegExp objects print incorrectly

Mon, 4 Jun 2012 23:52:42 -0500

#"x" is currently printing as #</x/>

js/RegExp needs an IPrintable implementation: (-pr-seq [re _] (list "#\"" (.-source re) "\""))

Unfortunately, this is blocked by the same GClosure issue as http://dev.clojure.org/jira/browse/CLJS-68

[CLJS-297] Eliminate :meta, :vector, :set, and :map ops

Fri, 31 Aug 2012 09:24:51 -0500

The attached patch eliminates the :meta, :set, :vector, and :map ops.

These four operations can be defined more simply in terms of
calls to with-meta, set, vector, and hash-map respectively.

The compiler was optimizing construction of vectors and maps. Now,
those optimizations are implemented as macros. Additionally, sets
are optimized in much the same way.

3 files changed, 52 insertions, 99 deletions

Also worth mentioning: as macros instead of ops & emit methods, these optimizations can apply to any backend. The macros create ClojureScript forms, rather than manually generating JavaScript.

[CLJS-294] AST contains munged symbols

Sun, 3 Jun 2012 17:12:28 -0500

All of the symbols in the abstract syntax tree are munged according for use in JavaScript. This is a problem because it means the AST is lossy and new compiler backends may have differing munging rules.

The attached patch removes all munging from the analysis phase and moves it into the emit phase. The emit phase is backend specific, so it's an appropriate place for munging.

[CLJS-289] Represent ast :children as a vector of keys

Wed, 29 Aug 2012 00:09:12 -0500

See discussion here: https://groups.google.com/d/topic/clojure-dev/vZLVKmKX0oc/discussion

Summary: Duplication of ast nodes in various keys and in :children is problematic for some users. In particular, it doesn't play nicely with printing. A solution is needed which preserves "The AST is data. Period."

The attached patch makes no changes to how the sub nodes are currently stored outside of the :children key. Instead, it replaces :children values with a vector of keys into the main ast node. This preserves child ordering and allows a children function to be defined as:

(defn children [ast]
(mapcat #(if (coll? %) % [%]) ((apply juxt (:children ast)) ast)))

The attached patch has two caveats: 1) Many (but not all?) blocks will now be present in the children hierarchy as 'do forms. 2) Interleaved forms are intentionally bugged with respect to ordering. The :children vector for those forms match the actual behavior, not the expected behavior. This can be fixed along with http://dev.clojure.org/jira/browse/CLJS-288

[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-1200] RestFn & ArraySeq performance

Thu, 18 Apr 2013 16:03:25 -0500

I was profiling one of my projects and noticed a hotspot inside functions using rest arguments.

Most overloads of RestFn.invoke will construct an ArraySeq object. The ArraySeq constructor calls java.lang.Class.getComponentType, which seems to be pretty slow. The array's component type is cached in a field on the ArraySeq object for the sole purpose of passing it to Reflector.prepRet. I'm not entirely sure of the total utility of prepRet, but it's clearly a no-op when passed Object.class, such as the case with the non-specialized base class of ArraySeq: the component type of object[] is Object.class.

The attached patch eliminates the component type field from ArraySeq and passes Object.class to prepRet directly. It may be possible to eliminate calls to prepRet all together, but I'll assume that's a different ticket. With this patch, ArraySeq initialization no longer shows up as a hotspot when profiling.

Before the patch:

user=> (dotimes [n 10] (time (dotimes [i 5000000] ((fn [& args]) 1 2 3 4))))
"Elapsed time: 874.742 msecs"
"Elapsed time: 900.277 msecs"
"Elapsed time: 911.164 msecs"
"Elapsed time: 872.132 msecs"
"Elapsed time: 885.495 msecs"
"Elapsed time: 897.537 msecs"
"Elapsed time: 879.691 msecs"
"Elapsed time: 888.52 msecs"
"Elapsed time: 871.556 msecs"
"Elapsed time: 1088.682 msecs"

After the patch:

user=> (dotimes [n 10] (time (dotimes [i 5000000] ((fn [& args]) 1 2 3 4))))
"Elapsed time: 628.144 msecs"
"Elapsed time: 634.163 msecs"
"Elapsed time: 617.397 msecs"
"Elapsed time: 622.714 msecs"
"Elapsed time: 646.743 msecs"
"Elapsed time: 648.708 msecs"
"Elapsed time: 629.223 msecs"
"Elapsed time: 638.058 msecs"
"Elapsed time: 725.473 msecs"
"Elapsed time: 636.909 msecs"

That's about a 30% reduction in execution time.

Granted it only represents a change of 52 nanoseconds per RestFn invoke (181 ns to 129 ns), but this actually was a pretty decent win for a library that makes makes almost exclusively variadic function calls in a tight loop.

[CLJ-1165] Forbid varargs defprotocol/definterface method declarations because those cannot be defined anyway

Thu, 4 Apr 2013 19:24:27 -0500

Protocol, interface method declarations don't allow for varags. Currently, for example

  (defprotocol FooBar
    (foo [this & more]))

compiles just fine, and & is interpreted as a usual argument that happens to be
named & without special meaning. But clearly, the user wanted to specify a
varags parameter here. The same applies to definterface.

Similarly, providing method implementations via defrecord, deftype, and reify
don't allow for varags (but dynamic extensions via extend do).

So this patch makes defprotocol and definterface throw an
IllegalArgumentException if a user tries to use varargs in method signatures.

Similarly, defrecord, deftype, and reify throw an IllegalArgumentException if
any method implementation arglist contains a varargs argument.

This patch is a cut-down variant of my patch to http://dev.clojure.org/jira/browse/CLJ-1024
which has been reverted shortly before Clojure 1.5 was released. The ~~CLJ-1024~~ patch
was the same as this one, but it has also forbidden destructuring in defprotocol and
definterface. This was a bit too much, because although destructuring has no
semantic meaning with method declarations, it still can serve a documentation purpose.

This has been discussed on the list: https://groups.google.com/d/topic/clojure-dev/qjkW-cv8nog/discussion

[CLJ-1161] sources jar has bad versions.properties resource

Fri, 12 Apr 2013 09:36:58 -0500

The "sources" jar (at least since Clojure 1.4 and including 1.5 RC) has a bad version.properties file in it. The resource clojure/version.properties is literally:

version=${version}

The regular Clojure jar has the correct version string in that resource.

I came across a problem when I was experimenting with the sources jar (as used by IDEs). I naively added the sources jar to my classpath, and Clojure died on start up. The bad clojure/versions.properties file was found first, which led to a parse error as the clojure version was being set.

[CLJ-1112] Var loading-verbosely should initialize from a JVM system property

Thu, 22 Nov 2012 02:14:32 -0600

I often find myself adding :verbose to a (require) or (use) clause of my (ns) in order to debug problems (especially macros, or bad namespace declarations). It would be very nice if I could define a JVM system property (say -Dclojure.load-verbosely=true) to default loading-verbosely to true for a REPL session, or as part of a build.

Sometimes I just like to see that namespaces load as a measure of progress, when starting an application, or when running a set of tests.

[CLJ-1094] Zero-arity versions of every-pred and some-fn

Thu, 25 Oct 2012 07:12:35 -0500

This patch adds zero-arity versions of every-pred and some-fn with these semantics.

(every-pred) === (constantly true)
(some-fn)    === (constantly nil)

These variants are useful in situations like the following:

;; compute-preds-for may return zero or many predicate fns
(let [preds (compute-preds-for something)]
  (filter (apply every-pred preds) some-coll))

[CLJ-1074] Read/print round-trip for +/-Infinity and NaN

Mon, 3 Dec 2012 13:18:40 -0600

A few float-related forms (namely, Double/POSITIVE_INFINITY, Double/NEGATIVE_INFINITY, Double/NaN) are not eval-able after a round-trip via

(read-string (binding [*print-dup* true] (pr-str f))

The two options I see are to provide print-method implementations for these and their Float cousins, or to make Infinity, -Infinity, +Infinity, and NaN readable values. Since it sounds like edn may want to provide a spec for these values (see https://groups.google.com/d/topic/clojure-dev/LeJpOhHxESs/discussion and https://github.com/edn-format/edn/issues/2), I think making these values directly readable as already printed is preferable. Something like Double/POSITIVE_INFINITY seems too low-level from edn's perspective, as it would refer to a Java class and constant.

I'm attaching a patch implementing reader support for Infinity, -Infinity, +Infinity, and NaN.

[CLJ-1073] Make print-sequential interruptible

Fri, 1 Mar 2013 10:18:01 -0600

This allows print-sequential to be interrupted by Thread.interrupt(), rather than requiring clients to resort to Thread.stop(). This is especially helpful when printing very large sequences.

See also clojure-dev discussion at https://groups.google.com/d/topic/clojure-dev/vs0RNUQXiYE/discussion

[CLJ-1066] No dependency on jsr166y

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

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

— snip —
Setup:

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

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

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

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

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

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

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

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

Have a nice day

Wolodja

[CLJ-1061] when-first double evaluation

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

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

Patch attached. The main diff is:

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

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

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

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

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

Please see attached code and patch.

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

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

Current behaviour of clojure.data/diff:

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

Proposed behaviour:

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

[CLJ-1010] A left-to-right-variant of `comp`

Thu, 14 Jun 2012 18:27:23 -0500

The function composition function `comp` is quite inefficient in cases like `(apply comp large-seq-of-fns)`, because its arity-greater-than-3 version reverses the seq.

I would be great if there was an alternative `comp*` (or whatever) function which is just like `comp` but composes left-to-right.

[CLJ-991] partition-by reducer

Mon, 4 Mar 2013 14:49:42 -0600

partition-by reducer

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

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

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

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

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

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

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

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

[CLJ-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-960] Capture :column metadata (needed for ClojureScript source maps)

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

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

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

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

Clojure JIRA

[TMACRO-2] protect let-bound symbols from macrolet expansion

[MTOWER-1] README should be updated to conform to contrib standard

[MCOMB-1] math.combinatorics README should be updated to conform to contrib standard

[LOGIC-64] Support inequalities in finite domain sugar

[LOGIC-44] ex* could expand macros in patterns

[CLJS-485] clojure.string/replace ignores regex flags

[CLJS-441] Require implicit 'do nodes for all blocks in AST

[CLJS-440] Replace :is-loop flag in AST with distinct :loop op

[CLJS-437] Missing "Too few arguments to if" check

[CLJS-432] Include line and file information in error messages

[CLJS-431] namespace and name fail on '/

[CLJS-426] subvec function not behaving consitently with invalid subranges

[CLJS-424] Internal representation of keywords can not be differentiated by printable characters

[CLJS-416] emit-block doesn't use context argument

[CLJS-409] Small code cleanup for emitting goog.provide statements

[CLJS-408] Include :form on fn :methods in AST

[CLJS-398] new macro cljs.core/extend-instance

[CLJS-397] Omit var reads in statement context

[CLJS-394] PersistentTreeSet lookup bug

[CLJS-370] Incorrect behavior of integer? for integral floating point expressions

[CLJS-369] gensyms break re-analyze; prevents variable shadowing analysis

[CLJS-360] Analyzer incorrectly merges metadata when redefining vars

[CLJS-326] hash-set and PersistentHashSet/fromArray == faster set construction

[CLJS-321] Support with-out-str

[CLJS-320] memfn not supported

[CLJS-319] missing spaces when printing the same thing more than once

[CLJS-304] Comparing a js/Date to nil throws

[CLJS-301] Inline instance?

[CLJS-300] RegExp objects print incorrectly

[CLJS-297] Eliminate :meta, :vector, :set, and :map ops

[CLJS-294] AST contains munged symbols

[CLJS-289] Represent ast :children as a vector of keys

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

[CLJ-1200] RestFn & ArraySeq performance

[CLJ-1165] Forbid varargs defprotocol/definterface method declarations because those cannot be defined anyway

[CLJ-1161] sources jar has bad versions.properties resource

[CLJ-1112] Var *loading-verbosely* should initialize from a JVM system property

[CLJ-1094] Zero-arity versions of every-pred and some-fn

[CLJ-1074] Read/print round-trip for +/-Infinity and NaN

[CLJ-1073] Make print-sequential interruptible

[CLJ-1066] No dependency on jsr166y

[CLJ-1061] when-first double evaluation

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

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

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

[CLJ-1018] range's behavior is inconsistent

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

[CLJ-1010] A left-to-right-variant of `comp`

[CLJ-991] partition-by reducer

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

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

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

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

[CLJ-1112] Var loading-verbosely should initialize from a JVM system property