A Dynamic Programming Language for the JVM
On March 20th, I gave a talk on Clojure and concurrency at a meeting of the Western Mass Developer's Group. The slides, source code for the demo, and audio from the talk are online.
4/9/2008 Update: Video of the presentation is now up on Clojure TV.
4/2/2008 Update: The audio for the presentation has been replaced with a glitch-free version, so if you've been suffering through, or abandoned, the first go round, please download the latest.
Many new features, including anonymous fn reader syntax, functional tree zippers, streamlined documentation and metadata in defn/defmacro, first-class sets and set algebra, proxies that can extend classes, comprehensive in-source documentation, and many new library functions. Not all of the new functionality has documentation in the prose part of the site yet, but the new API doc page should be comprehensive.
There is some renaming/removing in this release:
removed implement, use proxy
renamed set to ref-set
renamed ! to send
renamed select to select-keys
renamed to-set to set
renamed scan to dorun
renamed touch to doall
Thanks to all for your feedback and support!
Rich
Changelist:
I've added single-page documentation for all of Clojure's functions and macros, arranged alphabetically within namespace. It is generated from the source and reflects the current (SVN) version.
On March 20th, I will be giving a talk on Clojure at the regular meeting of the Western Mass Developer's Group.
The meeting will be at 243 King Street in Northampton and will start at 6:30.
Rich
I hope to do a series of screencasts on Clojure. They will be informal (often recorded at think-tank lunches I do with some friends of mine), but hopefully informative. Both halves of the first one are up.
Rich
Clojure has offered the ability to create instances of interfaces dynamically through its implement macro. This feature was built upon the java.lang.reflect.Proxy system, and, like it, was limited to deriving from interfaces only.
I've added to Clojure (in SVN as of rev. 708, not yet in release) direct dynamic proxy generation through the new proxy macro. It works just like implement with these differences:
The first item in the vector of supers can be a non-interface class. (If no class is provided it defaults to Object)
The vector of interfaces is followed by a (possibly empty) vector of arguments to the superclass constructor.
Each method fn is now implicitly passed an additional first arg called this, whose value is the proxy obect itself.
A method fn can have multiple arities.
A method fn can override a public or protected method of the superclass.
It is possible (using update-proxy) to alter the method/fn map of an existing proxy, and thus change its behavior, without altering its identity.
Proxies supercede implement, and all usage of implement should be changed to proxy, which is likely to offer better performance.
The use of proxy to implement interfaces is still primary. Deriving from concrete classes is not something I encourage generally. But we've all been faced with libraries that unfortunately require concrete derivation in order to interoperate - now with proxy you can.
There are some limitations of proxying vs direct derivation. While method fns can override protected methods, they have no other access to protected members, nor to super, as these capabilities cannot be proxied.
Please switch over your code to use proxy instead of implement, and try it out in situations where you need to derive from non-interface classes, and let me know how it works for you.
Rich
p.s. For those interested in bytecode generation and compiling, the implementation of proxy is written in Clojure (src/proxy.clj), and provides and example of using the embedded ASM bytecode library from Clojure itself.
I've added (in SVN as of rev. 698, not yet in release) purely functional, generic tree walking and editing, using a technique called a zipper. For background, see the paper by Huet. A zipper is a data structure representing a location in a hierarchical data structure, and the path it took to get there. It provides down/up/left/right navigation, and localized functional 'editing', insertion and removal of nodes. With zippers you can write code that looks like an imperative, destructive walk through a tree, call root when you are done and get a new tree reflecting all the changes, when in fact nothing at all is mutated - it's all thread safe and shareable! The next function does a depth-first walk, making for easy to understand loops:
(load-file "/Users/rich/dev/clojure/src/zip.clj")
(refer 'zip)
(def data '[[a * b] + [c * d]])
(def dz (vector-zip data))
;find the second *
(-> dz down right right down right node)
-> *
;remove the first 2 terms
(-> dz next remove next remove root)
-> [[c * d]]
;replace * with /
(loop [loc dz]
(if (end? loc)
(root loc)
(recur
(next (if (= (node loc) '*)
(replace loc '/)
loc)))))
-> [[a / b] + [c / d]]
;remove *
(loop [loc dz]
(if (end? loc)
(root loc)
(recur
(next (if (= (node loc) '*)
(remove loc)
loc)))))
-> [[a b] + [c d]]
;original is intact
(root dz)
-> [[a * b] + [c * d]]
Zipper constructors are provided for nested seqs, nested vectors, and the xml elements generated by xml/parse. All it takes is a 4-5 line function to support other data structures. The zipper support is in src/zip.clj.
Try it out and let me know what you think (on the Google Group),
Rich
I've just finished adding (as of SVN 694, not in release yet) in-code documentation for all public functions of Clojure. The documentation strings appear on the metadata of the var holding the function, under the :doc key. There are two new Repl-oriented helpers for accessing docs, (doc varname) and (find-doc "pattern"). doc prints the documentation for a var, including its name, arglist(s), Macro - if it is a macro, and the docstring. find-doc does the same for all vars whose name or documentation matches the supplied string, which is treated as a regex pattern.
Command-line arguments are now supported for Repl and Script. Anything following -- on the command line will be treated as a command-line argument to the application (i.e. not evaluated by Clojure) and will be available as a sequence of strings - *command-line-args*.
assoc and dissoc now support multiple key/vals and keys respectively.
I've renamed scan to dorun, and touch to doall, the idea being that when you need side-effects you should think "do__".
I've also added rand and rand-int. Find out about them by trying (find-doc "rand").
Please try out these new features. I hope to cut a release including them soon.
Rich
I've added (as of SVN rev 675, not yet in release) anonymous fn and arg literal reader syntax. An anonymous fn expression takes the form #(...) and turns into (fn [args] (...)), where args are determined by the presence of argument literals taking the form %, %n or %&. % is a synonym for %1, %n designates the nth arg (1-based), and %& designates a rest arg:
(map #(* 2 %) [1 2 3])
-> (2 4 6)
(map #(* 2 %1 %2) [1 2 3] [4 5 6])
-> (8 20 36)
;expansion:
(quote #(foo % %2 (bar %&)))
-> (fn* [p1__750 p2__751 & rest__752] (foo p1__750 p2__751 (bar
rest__752)))
(map #(. % (toString)) [1 2 :d])
-> ("1" "2" ":d")
(map #(/ 1 %) [1 2 3 4])
-> (1 1/2 1/3 1/4)
%
-> java.lang.Exception: ReaderError:(9,1) arg literal not in #()
Many significant new features, including first-class namespaces, pervasive abstract destructuring binding, list comprehensions, var metadata, regex literals and more! Browse through the site for details.
There is some renaming/removing in this release:
Folded strcat functionality into str
Removed export, *exports*, unintern, unimport
Renamed ns-exports to ns-publics
Made fn and let macros, which, by the end of boot.clj, do destructuring, as do all macros which emit them.
Removed thisfn, use (fn name [] ...)
boot.clj is now loaded from .jar, no longer from command line.
Renamed eql? to =, compares numbers without regard for type.
Renamed struct to struct-map
Changelist:
Thanks to all for your feedback!
Rich
Thanks to all for your feedback!
Many new features and fixes, but a primary one is not in the code but on the site:
I've documented all Clojure special ops, macros and functions! Please browse around, I've added over 100 new entries, and a new section on Java Interop.
In this release:
This release adds the Agents system and includes many bug fixes.
I recently gave a talk on Clojure to the LispNYC group. Audio and slides from the talk are now available online.
I've added a feature tour to give an overview of Clojure in addition to the reference documentation.
There is also a new page in the reference describing Multimethods.
Featuring:
range function
Multimethods
Any object not explicitly handled by the compiler is self-evaluating
Copyright © Rich Hickey