What Language Features Can Be Added To Clojure Through Libraries?

For example pattern matching is a programming language f开发者_开发问答eature that can be added to the clojure language through macros: http://www.brool.com/index.php/pattern-matching-in-clojure

What other language features can be added to the language?

Off the top of my hat I have two examples, but I'm sure there are more.

• Contracts programming: https://github.com/fogus/trammel
• Declarative logic: https://github.com/jduey/mini-kanren

I think its a stupid question to ask what can be added, what you should ask is what you cant add. Macros allow you to hook into the compiler that mean you can do almost anything.

At the moment you cant add your own syntax to the language. Clojure does not have a user extenseble reader, this means you don't have any reader-macros (http://dorophone.blogspot.com/2008/03/common-lisp-reader-macros-simple.html). This is not because of a technical problem but more a decition by Rich Hickey (the Clojure creator).

What you can not do is implement features that need virtual maschine support like add tail call semantics or goto.

If you want to see some stuff that has been done: Are there any Clojure DSLs?

Note that this list is not 100% up to date.

Edit:

Since you seem you took pattern matching as an example (it is a really good example for the power of macros) you should really look at the match library. Its probebly the best fastest pattern matching library in Clojure. http://vimeo.com/27860102

You can effectively add any language features you like.

This follows from the ability of macros to construct arbitrary code at compile time: as long as you can figure out what code you need to generate in order to implement your language features, it can be achieved with macros.

Some examples I've seen:

• Query languages (Korma)
• Logic programming (core.logic)
• Image synthesis DSL (clisk)
• Infix notation for arithmetic
• Algebraic manipulation
• Declarative definition of realtime data flows (Storm, Aleph)
• Music programming (Overtone, Music As Data)

There are a few caveats:

• If the feature isn't supported directly by the JVM (e.g. tail call optimisation in the mutually recursive case) then you'll have to emulate it. Not a big deal, but may have some performance impact.
• If the feature requires a syntax not supported by the Clojure reader, you'll need to provide your own reader (since Clojure lacks an extensible reader at present). As a result, it's much easier if you stick to Clojure syntax/forms.
• If you do anything too unusual / unidiomatic, it probably won't get picked up by others. There is a lot of value in sticking to standard Clojure conventions.
• Beware of using macros where they are not needed. Often, just using normal functions (perhaps higher order functions) is sufficient to implement many new language features. The general rule is: "don't use macros unless you absolutely need to".