Editando Clojure (sección)

== Ejemplos ==
[[Hola mundo]]. Nótese que dada la naturaleza del REPL, no es necesaria una orden de ''impresión''.

<syntaxhighlight lang="lisp">
"¡Hola, mundo!"
</syntaxhighlight>

Un generador de números únicos y consecutivos que soporta llamadas concurrentes:

<syntaxhighlight lang="lisp">
(let [i (atom 0)]
  (defn generar-id-unica
    "Devuelve un identificador numérico distinto para cada llamada."
    []
    (swap! i inc)))
</syntaxhighlight>

Una subclase anónima de <code>[http://java.sun.com/javase/6/docs/api/java/io/Writer.html java.io.Writer]</code> que no escribe en ningún sitio y una macro que lo usa para silenciar todas las expresiones evaluadas con ella.

<syntaxhighlight lang="lisp">
(def bit-bucket-writer
  (proxy [java.io.Writer] []
    (write [buf] nil)
    (close []    nil)
    (flush []    nil)))

(defmacro noprint
  "Evalua la expresiones dadas con todas las impresiones a *out* silenciadas."  
  [& forms]
  `(binding [*out* bit-bucket-writer]
     ~@forms))

(noprint
 (println "Hello, nobody!"))
</syntaxhighlight>

En este ejemplo diez hilos manipulan una estructura de datos compartida, que consiste en cien vectores que contienen diez números únicos al inicio secuenciales. Cada hilo elige dos posiciones aleatorias en dos vectores aleatorios y los intercambia. Todos los cambios en los vectores se hacen dentro de transacciones usando el sistema de [[memoria transaccional por software]] de Clojure. Es por eso que incluso después de mil iteraciones no se pierde ningún número.

<syntaxhighlight lang="lisp">
(defn run [nvecs nitems nthreads niters]
  (let [vec-refs (vec (map (comp ref vec)
                           (partition nitems (range (* nvecs nitems)))))
        swap #(let [v1 (rand-int nvecs)
                    v2 (rand-int nvecs)
                    i1 (rand-int nitems)
                    i2 (rand-int nitems)]
                (dosync
                 (let [temp (nth @(vec-refs v1) i1)]
                   (alter (vec-refs v1) assoc i1 (nth @(vec-refs v2) i2))
                   (alter (vec-refs v2) assoc i2 temp))))
        report #(do
                 (prn (map deref vec-refs))
                 (println "Distinct:"
                          (count (distinct (apply concat (map deref vec-refs))))))]
    (report)
    (dorun (apply pcalls (repeat nthreads #(dotimes [_ niters] (swap)))))
    (report)))

(run 100 10 10 100000)
</syntaxhighlight>

Salida del ejemplo anterior:
<syntaxhighlight lang="lisp">
([0 1 2 3 4 5 6 7 8 9] [10 11 12 13 14 15 16 17 18 19] ...
 [990 991 992 993 994 995 996 997 998 999])
Distinct: 1000
 
([382 318 466 963 619 22 21 273 45 596] [808 639 804 471 394 904 952 75 289 778] ...
 [484 216 622 139 651 592 379 228 242 355])
Distinct: 1000
</syntaxhighlight>