Clojure JIRA

[CLJS-22] closures act like js not clojure

Fri, 22 Jul 2011 12:25:00 -0500

(loop [i 0 j ()]
(if (< i 5)
(recur (inc i) (conj j (fn [] i)))
(map #(%) j)))

In Clojure, this returns: `(4 3 2 1 0)`

In ClojureScript it returns: `(5 5 5 5 5)`

Imported from github issue #85

[CLJS-23] Inconsistent munging of namespaces with dashes

Thu, 28 Jul 2011 08:15:18 -0500

When creating a file with a namespace like `foo.bar-baz` the compiled file will have a dash in the `goog.provide` but then use underscores within the code.

goog.provide('foo.bar-baz');
foo.bar_baz.something = ....

When requiring this namespace in another file the `goog.require` and the code both use dashes.

goog.require('foo.bar-baz');
var x = foo.bar-baz.something();

Assuming that file names must use underscores instead of dashes, as in Clojure on the JVM, there is a related issue in the `cljs.closure` namespace where it incorrectly creates file names from namespaces with dashes. The first line in the let form of the `get-compiled-cljs` function is the problem and can be replaced with a call to something like:

```clj
(defn ns->file-name [s]
(let [ns (name s)
path (string/replace (munge ns) \. java.io.File/separatorChar)]
(str path ".cljs")))
```

Imported from github issue #86

[CLJS-21] implement memoize

Mon, 25 Jul 2011 22:02:51 -0500

Imported from github issue #84

[CLJS-20] Implement rem, mod, quot

Thu, 28 Jul 2011 12:52:28 -0500

rem, mod, and quot might be useful for the demo app.

Imported from github issue #83

[CLJS-17] move to public clojure org repo

Fri, 22 Jul 2011 06:42:38 -0500

Clone current repo. Needs to be live with talk Wed night

Will wiki and other things move automatically?

Imported from github issue #70

[CLJS-19] Record Wednesdays talk

Fri, 22 Jul 2011 06:43:59 -0500

Bring in Zi8, charger, tripod(s), and extra storage

Imported from github issue #74

[CLJS-18] Live Stream Talk

Fri, 22 Jul 2011 06:43:04 -0500

Bring an HD webcam to ClojureNYC meeting
Live stream Rich's talk

Imported from github issue #73

[CLJS-15] compare, comparator, sort, sort-by

Fri, 29 Jul 2011 08:41:13 -0500

Imported from github issue #68

[CLJS-16] amap, areduce, aclone, into-array, make-array, object-array, to-array-2d

Sat, 21 Apr 2012 11:31:41 -0500

Implement the valid array functions.

Imported from github issue #69

[CLJS-14] (quot)

Fri, 22 Jul 2011 08:27:40 -0500

Implement (quot)

Imported from github issue #67

[CLJS-12] Implement delays

Thu, 28 Jul 2011 15:08:09 -0500

The implementation of Delay objects, the `delay` macro, and the `delay?` predicate (probably a good excuse to implement `realized?` also, but probably as part of a different ticket) should be fairly straight-forward to implement.

Imported from github issue #65

[CLJS-13] Implement ratios

Mon, 3 Sep 2012 15:30:19 -0500

Clojure.java contains support for Ratio types. It would be nice to have them in Clojurescript as well, but as far as I can tell this would be new development (please comment if I'm wrong). That is, there is no implementation of Ratio types in GClosure so this feature would need to be implemented from the ground up. In additional to the Ratio type, the following corresponding functions would also need implementations:

`ratio?`
`numerator`
`denominator`
`rationalize`

Plus the ratio type would need to be rolled into the existing mathematical frameworkings.

Imported from github issue #66

[CLJS-10] Supported Closure Compiler options

Fri, 16 Sep 2011 08:31:25 -0500

Currently the interface to the Closure compiler in cljs.closure supports only two compiler options:

optimizations
pretty-print

From the repl it looks like this:

(-compile '(defn add-one [x] (inc x)) {:optimizations :advanced :flags #{:pretty-print}})

Do we want to support all options are just a subset?

Whatever we decide to support, said support will need to be added to cljs.closure.

See:

https://github.com/relevance/clojurescript/blob/master/src/clj/cljs/closure.clj#L110
http://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/javascript/jscomp/CommandLineRunner.java
http://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/javascript/jscomp/CompilerOptions.java

1. Externs

Currently all default externs are loaded. If we decide to go with a subset of options we may want to follow the lead of CommandLineRunner and allow an option to provide custom externs and one to only use the custom externs.

Imported from github issue #62

[CLJS-11] Command line build tool

Tue, 29 Nov 2011 06:30:45 -0600

First, do we want one? Now that we can build from the repl with cljs.closure/build, do we want to provide a command line tool? Build time will be much faster from the repl as there is no JVM startup time and only a one time loading of resources (which is significant).

If we do want one then will it be a bash script or a main class that we package in a jar? In either case we will have to make something to convert command line args into a Clojure map of options.

Imported from github issue #63

[CLJS-8] clojure.string

Sat, 6 Aug 2011 09:40:41 -0500

Port clojure.string to cljs

Imported from github issue #47

[CLJS-7] document diffs from Clojure

Fri, 29 Jul 2011 09:43:30 -0500

section by section comparison with Clojure, documenting what is different or absent

Imported from github issue #40

[CLJS-9] Create Sample Application

Sat, 7 Apr 2012 20:31:52 -0500

Remaining items:

host the application somewhere
links to compiled code
someone other than Brenton should review the code (is this a good example of how to write ClojureScript?)
could use a little more design work

Since I (Brenton) won't be able to do any of these things, I am relinquishing this task to someone who can.

[CLJS-6] range

Fri, 29 Jul 2011 09:42:57 -0500

You know, the function.

Imported from github issue #39

[CLJS-5] Compiler should emit optional source maps

Sat, 22 Dec 2012 16:29:56 -0600

== New Notes ==

http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/

Source map support will be landing in Chrome in 6 weeks.

== Old Notes ==

Google's debugging tooling consists of at least these two big pieces:

The `--create_source_map` compiler flag, which generates a table mapping source JS to compiled JS
The [Closure Inspector](http://code.google.com/closure/compiler/docs/inspector.html), a Firefox plugin that uses the source maps to provide error messages pointing to original code instead of compiled code

Open Questions

What does integrating with Closure Inspector look like?
Can we use code from gclosure to generate our own cljs �� compiled JS mappings?
Would we need to modify Closure Inspector?

Imported from github issue #31

[CLJS-4] Try compiler macros for math ops

Fri, 23 Sep 2011 11:58:18 -0500

I've made it so macro expansion stops when expansion does not differ from source form. This combined with the fact that we have separate Clojure namespaces for macros means that ordinary macros can act as compiler macros in cljs. Just define a macro with the same name as the function.

Note that you will need the complete definition of the function as well - it will be used when the function is used as a value, or via some alias. The macro will only come into play when compiler sees call by original name.

Try this on e.g. * and report back.

Imported from github issue #15

[CLJS-3] testing spike (assert, test.generative)

Tue, 23 Aug 2011 17:38:39 -0500

Things we will need to have/work around:

clojure.walk
rethink deep-take (simple approach: omit)
- or have a bindable var for compare-depth
fully qualified name hack
eval (macro time only?)
atoms
binding
development time namespace walking, or some other way to find tests
math fns

Imported from github issue #12

[CLJS-2] Implement apply

Fri, 29 Jul 2011 08:37:21 -0500

The time for `apply` is nigh.

Is it as simple as emitting `afn.apply(ctx, args...)`?

Imported from github issue #11

[CLJS-509] Spurious warning about symbol not being a protocol

Tue, 21 May 2013 09:22:44 -0500

"lein cljsbuild" generates "Symbol X is not a protocol" warning. The following code snippet reproduces the issue. Renaming "my.foo" namespace to "foo" compiles with no warning.

;; file:: foo.cljs
(ns my.foo)

(defprotocol IFoo
(bar[this]))

;; file: fubar.cljs
(ns fubar
(:require
[my.foo :as foo]))

(deftype FuBar []
foo/IFoo
(bar [this]))

cljs output:
WARNING: Symbol foo/IFoo is not a protocol at line 5 src/fubar.cljs

[CLJS-508] Missing IReduce implementations and typo in clojure.core.reducers/append!

Tue, 21 May 2013 10:03:02 -0500

1) IReduce protocol is missing implementation for array and List.
2) append! uses (.add array), while the correct array method name is push

Patch attached.

Note: what is your experience with array.push performance? ClojureScript reducers/foldcat uses arrays for append! / cat implementation. My experience was that (into [] ...) using conj! and TransientVector was at least 5 times faster than reducers/foldcat using array and push. The reason is probably inefficient push implementation in Chrome/V8

[CLJS-507] Persistent Data Structure Benchmark

Mon, 20 May 2013 14:35:42 -0500

Put together an easy to run series of persistent data structure benchmarks that can be easily run. For example we would like to submit to this Mozilla ticket http://bugzilla.mozilla.org/show_bug.cgi?id=874174

[CLJS-506] Flag to disable minification in advanced mode

Sun, 19 May 2013 10:11:15 -0500

Problem:
Some code has different semantics when compiled in advanced mode.
Clojurescript tries to minimize those cases, but examples are usage of aget or forgotten externs files.
There exits closure compiler options to generate names based on original expressions, even with advanced optimizations.
However, there exists no clojurescript compiler option for that.

Proposal:
Add a :debug compiler option to clojurescript, which can be set to true to turn the following closure compiler options on:

generatePseudoNames true
anonymousFunctionNaming AnonymousFunctionNamingPolicy/UNMAPPED

Attached patch implements this, as a result the compiled test suite is indeed quite readable.