Introduction to Clojure - Digital Digressions by Stuart … · Stuart Sierra Relevance, Inc....

Introduction toClojure

@stuartsierra#strangeloop

1Sunday, September 18, 2011

Bullet Points• The REPL

• Data and Code

• Working with Data

• Destructuring

• Higher-Order Functions

• Sequences

• Java Interop

• Libraries

• Namespaces

• Concurrency

• Macros

• Recursion

Stuart SierraRelevance, Inc.

Clojure/core

Clojure contributor

Where are you from?

• Lisp?

• Java / C# / C++

• ML / Haskell?

• Python / Ruby / Perl?

• Clojure?

• Multithreaded programming?

The REPL

• READ

• EVALuate

• PRINT

• LOOP

The REPL

user=> (+ 1 2 3)6user=>

"you arehere"

type anexpression press

result

The REPL

user=> (+ 1 2 3)6user=>

The REPL

user=> (println "Hello, World!")Hello, World!nil

expression withside effects

return valueprinted output

REPL Helpers: doc

user=> (doc when)-------------------------clojure.core/when([test & body])Macro Evaluates test. If logical true, evaluates body in an implicit do.nil

Fully-qualified name

Arguments

REPL Helpers: find-doc

user=> (find-doc "sequence")... all definitions with "sequence" in their documentation ...nil

REPL Helpers: apropos

user=> (apropos "map")(sorted-map ns-unmap zipmap map mapcat sorted-map-by map? amap struct-map proxy-mappings pmap map-indexed ns-map array-map hash-map)

user=> (source take)(defn take "Returns a lazy sequence of the first n items in coll, or all items if there are fewer than n." {:added "1.0" :static true} [n coll] (lazy-seq (when (pos? n) (when-let [s (seq coll)] (cons (first s) (take (dec n) (rest s)))))))nil

REPL Helpers: source

Source code ofthe 'take' function

Data and Code

Literals

example Java type

"hello" String

\e Character

42 Long

6.022e23 Double

1.0M BigDecimal

9223372036854775808N clojure.lang.BigInt

22/7 clojure.lang.Ratio

#"hel+o" java.util.regex.Pattern

Literals

example Java type

nil null

true false Boolean

println even? + clojure.lang.Symbol

:beta ::gamma clojure.lang.Keyword

Data Structures

type example properties

list (1 2 3) singly-linked,grow at front

vector [1 2 3] indexed,grow at end

map {:a 1, :b 20} key/value pairs

set #{1 7 3} unordered, unique keys

Commas,, are,,,,,,whitespace,,,,,

Comments

;;; File-level comment

(let [x 6, y 7] ;; Block-level comment, ;; indented like code (println "Hello, World!") (* 6 7)) ; end-of-line comment

Structure

(println "Hello, World!")

listsymbol string

Semantics

(println "Hello, World!")

function call argument

function

defn Semantics

(defn greet "Returns a friendly greeting" [your-name] (str "Hello, " your-name))

define a fndocstring

arguments

fn name

fn body

defn Structure

(defn greet "Returns a friendly greeting" [your-name] (str "Hello, " your-name))

listsymbol

string

vector

All forms created equalform syntax example

function list (println "hello")

"operator" list (+ 1 2)

method call list (.trim " hello ")

loading list (require 'mylib)

metadata list (with-meta obj m)

control flow list (when valid? (proceed))

scope list (let [x 5] ...)

Invocation Forms

(op ...)

• Special Form• Macro• Function

or any invocable thing• Expression which returns

an invocable thing

Invocation Forms

user=> (1 2 3)ClassCastException java.lang.Long cannot be cast to clojure.lang.IFn

Invocation Forms

invocable things

not an invocable thing

14 Special Forms

def if fn letloop recur do

new . throw tryset! quote var

Special Form: def

(def symbol value-expr?)

Special Form: def

user=> (def answer (* 6 7))#'user/answeruser=> answer42 Var

Special Form: if

(if condition then-expr else-expr?)

Special Form: if

user=> (if (even? 42) "even" "odd")"even"user=> (if (even? 7) "even")nil

Truthiness

Clojure Java Common Lisp

Scheme

null value

boolean values

"falsey"

"truthy"

nil null nil or ()

true / false true / false t / nil #t / #f

nil or false false nil or () #f

everything else true everything else

everything else

Special Form: do

(do exprs*)

Special Form: do

user=> (do 1 2 3)3user=> (do (println 42 "is even") 42)42 is even42

Special Form: do

user=> (if (even? 42) (do (println 42 "is even") 42)))42 is even42

Macro: when

(when condition exprs*)

(if condition (do exprs*))

Macro: when

user=> (when (even? 42) (println 42 "is even") 42)42 is even42

Special Form: quote

(quote form)

Special Form: quote

user=> (quote (1 2 3))(1 2 3)user=> '(1 2 3)(1 2 3)user=> (list 1 2 3)(1 2 3)

Special Form: let

(let [bindings*] exprs*)

Special Form: let

user=> (let [x 6, y 7] (* x y))42

Binding forms

Value expressions

Special Form: let

user=> (let [x 6 y (+ x 1)] (* x y))42

Earlier bindingsavailable

Special Form: let

user=> (let [x 6 y (+ x 1)] (println (* x y)) (let [y 10] (println (* x y))))4260nil Rebinding is allowed

Special Form: let

user=> (let [x 5] (let [y x] (let [y y] (let [z (+ x y)] z))))

Special Form: fn

(fn [params*] exprs*)

(fn ([params*] exprs*)+)

Special Form: fn

user=> (fn [x] (+ x 5))#<user$eval1456$fn__1457>user=> (def add5 (fn [x] (+ x 5)))#'user/add5user=> (add5 10)15

compiled fn

Macro: defn

(defn symbol [params*] exprs*)

(def symbol (fn [params*] exprs*))

user=> (defn greet ([] (greet "Clojure" "programmer")) ([name] (greet name "the programmer")) ([first-name last-name] (println "Hello," first-name last-name)))#'user/greetuser=> (greet)Hello, Clojure programmerniluser=> (greet "Stuart")Hello, Stuart the programmerniluser=> (greet "Stuart" "Sierra")Hello, Stuart Sierranil

Variadic

user=> (defn greet ([name] (println "Hello," name)) ([name & others] (println "Hello," name "and friends" others)))#'user/greetuser=> (greet "Stuart")Hello, Stuartniluser=> (greet "Stuart" "Aaron" "Fogus" "Chouser")Hello, Stuart and friends (Aaron Fogus Chouser)nil

Working with Data

Value Equality

user=> (= [1 2 3] [1 2 3])trueuser=> (= [1 2 3] [1.0 2.0 3.0])trueuser=> (= [1 2 3] '(1 2 3))true

Reference Equality

user=> (= (StringBuilder. "a") (StringBuilder. "a"))false user=> (identical? [1 2 3] [1 2 3])falseuser=> (identical? 2.0 2)false

Reference Equality

user=> (= :a :a)true user=> (identical? :a :a)trueuser=> (= 'a 'a)trueuser=> (identical? 'a 'a)false

Collections

user=> (count [:a :b :c])3user=> (coll? [:a :b :c])trueuser=> (vector? [:a :b :c])trueuser=> (list? [:a :b :c])false

• List

• Vector

Sequential Things

user=> (def v [:a :b :c :d])#'user/vuser=> (first v):auser=> (second v):buser=> (def w (vector 10 11 12 13))#'user/wuser=> (nth w 3)13

user=> (def v [:a :b :c :d])#'user/vuser=> (conj v :more)[:a :b :c :d :more]

user=> (def lst (list 1 2 3 4))#'user/lstuser=> (conj lst :more)(:more 1 2 3 4)

Vectors growat the end

Lists growat the front

Associative Things

• Map

• Hash map

• Array map

• Vector (sometimes)

Maps: get

user=> (def m {:a 1 :b 2})#'user/muser=> (get m :a)1user=> (m :a)1user=> (:a m)1

Maps areinvocable

So are keywords

Maps: assoc

user=> (def m (hash-map :a 1 :b 2))#'user/muser=> (assoc m :c 3 :d 4){:a 1, :c 3, :b 2, :d 4}user=> (assoc m :a 17){:a 17, :b 2} new map

with addedkey-value pairs

user=> (def m {:a 1 :b 2})#'user/muser=> (dissoc m :a){:b 2}user=> (keys m)(:a :b)user=> (conj m [:c 3]){:a 1, :c 3, :b 2}

conj on a maptakes a vector pair

Maps: merge

user=> (def m {:a 1 :b 2})#'user/muser=> (merge m {:b 17 :c 22}){:a 1, :c 22, :b 17}

Maps: zipmap

user=> (zipmap [:a :b :c] [1 2 3]){:c 3, :b 2, :a 1}

Maps: get-in

user=> (def person {:name {:first "Stuart" :last "Sierra"} :address {:city "Brooklyn" :state "New York"}})#'user/personuser=> (:first (:name person))"Stuart"user=> (get-in person [:name :first])"Stuart"

Maps: assoc-in

user=> (def person {:name {:first "Stuart" :last "Sierra"} :address {:city "Brooklyn" :state "New York"}})#'user/personuser=> (assoc-in person [:name :last] "Halloway"){:name {:last "Halloway", :first "Stuart"}, :address {:state "New York", :city "Brooklyn"}}

Vectors are Associative

user=> (def v [:a :b :c])#'user/vuser=> (assoc v 1 "Hello")[:a "Hello" :c]

user=> (def s #{1 2 3})#'user/suser=> s#{1 2 3}user=> (conj s 17)#{1 2 3 17}user=> (conj s 2)#{1 2 3}

user=> (def v [1 2 3 1 2 3 4])#'user/vuser=> (set v)#{1 2 3 4}

Sets: contains?

user=> (def s #{1 2 3})#'user/suser=> (contains? s 3)trueuser=> (contains? s 17)false

Checks keys,not values

Sets: invocation

user=> (def s #{1 2 3})#'user/suser=> (s 3)3user=> (s 17)nil

Returns objectif it's in the set

Destructuring

user=> (def stuff [7 8 9 10])#'user/stuff

user=> (let [[a b c d] stuff] (list (+ a b) (+ c d))) (15 19)

Destructuring

(let [bindings*] exprs*)

Destructuring

(let [binding-form value-expr] exprs*)

Sequential Destructuring

(let [[a b c d] stuff] exprs*)

Binding form Value expression

(let [[a b c d] stuff] ...

(let [[a b c d] [7 8 9 10]] ...Evaluate

(let [a 7 b 8 c 9 d 10] ...

Destructure

user=> (def stuff [7 8 9 10])#'user/stuff

user=> (let [[a & others] stuff] (println a) (println others))7(8 9 10)nil

(let [[symbols+ & symbol] expr] exprs*)

Get the first one or more elements

Get all remaining elements

Associative Destructuring

user=> (def m {:a 7 :b 4})#'user/muser=> (let [{a :a, b :b} m] [a b])[7 4]

user=> (def m {:a 7 :b 4})#'user/muser=> (let [{:keys [a b]} m] [a b])[7 4]

Associative Destructuring

Keyword Destructuring

user=> (def m {:a 7 :b 4})#'user/muser=> (let [{:keys [a b c]} m] [a b c])[7 4 nil]

Destructuring with Default Values

user=> (def m {:a 7 :b 4})#'user/muser=> (let [{:keys [a b c] :or {c 3}} m] [a b c])[7 4 3]

Destructuring

(fn [params*] exprs*)

(defn symbol [params*] exprs*)

Destructuringworks here too

Nested Destructuring

user=> (def data {:a [1 2 3] :b {:c 4}})#'user/data

user=> (let [{[x & y] :a {:keys [c d] :or {d 10}} :b} data] (+ x c d))

Higher-Order Functions

user=> (def v [1 2 3 4])#'user/vuser=> (println v)[1 2 3 4]niluser=> (apply println v)1 2 3 4niluser=> (println 1 2 3 4)1 2 3 4nil

user=> (def v [1 2 3 4])#'user/vuser=> (map (fn [x] (* 5 x)) v)(5 10 15 20)

#() syntax

user=> (map (fn [x] (* 5 x)) v)(5 10 15 20)user=> (map #(* 5 %) v)(5 10 15 20) Same fn

user=> (def v [:a :b :c])#'user/vuser=> (def w [10 20 30 40 50])#'user/nuser=> (map vector v w)([:a 10] [:b 20] [:c 30])

reduce

user=> (reduce + [1 2 3 4])10user=> (+ (+ (+ 1 2) 3) 4)10

reduce

user=> (reduce + 100 [1 2 3 4])110user=> (+ (+ (+ (+ 100 1) 2) 3) 4)110

seed value

reduce

user=> (reduce (fn [m [k v]] (assoc m (name k) (+ 100 v))) {} {:a 1 :b 2}){"b" 102, "a" 101}

destructurekey-value pair

seed value

filter and remove

user=> (filter even? [1 2 3 4 5])(2 4)user=> (filter (set "aeiou") "Hello, World!")(\e \o \o)user=> (apply str (remove (set "aeiou") "Hello, World!"))"Hll, Wrld!"

Maps: assoc-in

user=> (def person {:name {:first "Stuart" :last "Sierra"} :address {:city "Brooklyn" :state "New York"}})#'user/personuser=> (assoc-in person [:name :last] "Halloway"){:name {:last "Halloway", :first "Stuart"}, :address {:state "New York", :city "Brooklyn"}}

Maps: update-in

user=> (def person {:name {:first "Stuart" :last "Sierra"} :address {:city "Brooklyn" :state "New York"}})#'user/personuser=> (update-in person [:name :last] #(.toUpperCase %)){:name {:last "SIERRA", :first "Stuart"}, :address {:state "New York", :city "Brooklyn"}}

identity

user=> (doc identity)-------------------------clojure.core/identity([x]) Returns its argument.nil

filter and identity

user=> (def v [1 2 3 nil 4 5 nil 6])#'user/vuser=> (filter identity v)(1 2 3 4 5 6)

user=> (doc fnil)-------------------------clojure.core/fnil([f x] [f x y] [f x y z]) Takes a function f, and returns a function that calls f, replacing a nil first argument to f with the supplied value x.

user=> (+ nil 3)NullPointerException clojure.lang.Numbers.opsuser=> (def add (fnil + 0))#'user/adduser=> (add nil 3)3

update-in and fnil

user=> (def m {:foo {:a 1 :b 2} :bar {:c 3}})#'user/muser=> (update-in m [:foo :a] inc){:foo {:a 2, :b 2}, :bar {:c 3}}user=> (update-in m [:baz :d] inc)NullPointerException clojure.lang.Numbers.opsuser=> (update-in m [:baz :d] (fnil inc 0)){:foo {:a 1, :b 2}, :bar {:c 3}, :baz {:d 1}}

frequencies

user=> (reduce (fn [m c] (update-in m [c] (fnil inc 0))) {} "a short sharp shock"){\space 3, \a 2, \c 1, \h 3, \k 1, \o 2, \p 1, \r 2, \s 3, \t 1}

user=> (frequencies "a short sharp shock"){\space 3, \a 2, \c 1, \h 3, \k 1, \o 2, \p 1, \r 2, \s 3, \t 1}

Sequences

first next first next first next

(def lst '(1 2 3))

Sequences

(def lst (range 1 4))#'user/lst

LazySeq

Sequences

(first lst)1

LazySeq

first next

LazySeq

Sequences

(second lst)2

LazySeq

first next

LazySeq

first next

LazySeq

(range)

(range end)

(range start end)

(range start end step)

infinite!

Infinite Sequences

user=> (map vector (range) [:a :b :c])([0 :a] [1 :b] [2 :c])

user=> (map-indexed vector [:a :b :c])([0 :a] [1 :b] [2 :c])

user=> (zipmap "abc" (range)){\c 2, \b 1, \a 0}

repeat

user=> (repeat 5 :a)(:a :a :a :a :a)

user=> (take 10 (repeat :b))(:b :b :b :b :b :b :b :b :b :b)

infinite!

user=> (seq [1 2 3])(1 2 3)user=> (seq {:a 1 :b 2 :c 3})([:a 1] [:c 3] [:b 2])user=> (seq #{1 2 3})(1 2 3)user=> (seq [])nil

Lazy vs. Strict

(with-open [file ...] (line-seq file))

returns lazy seqof lines in file

file is closed here

Lazy vs. Strict

(with-open [file ...] (doall (line-seq file))

force entire seqto be realized

doall, dorun, doseq

(doall sequence)

(dorun sequence)

(doseq [symbol sequence] ...body...)

returns sequence

returns nil

Java Interop

Java Types

Clojure Literal Java Type

"hello" java.lang.String

3.14 java.lang.Double

[1 2 3] java.util.List

{"a" 1, "b" 2} java.util.Map

(fn [x] (* x 5)) java.lang.Runnable

class and ancestors

user=> (class "hello")java.lang.Stringuser=> (ancestors (class "hello"))#{java.lang.CharSequence java.lang.Comparable java.lang.Object java.io.Serializable}

REPL Helpers: javadoc

user=> (javadoc java.io.Writer)"http://java.sun.com/javase/6/docs/api/java/io/Writer.html"

user=> (javadoc "hello")"http://java.sun.com/javase/6/docs/api/java/lang/String.html"

Java class

Object

Special Form: . (dot)

(. object method arguments*)

(. object field)

(. class static-method arguments*)

(. class static-field)

Instance Method Calls

user=> (. "hello" charAt 0)\h

user=> (.charAt "hello" 0)\h

Syntactic sugar

object method arguments

Static Method Calls

user=> (. Long valueOf "42")42

user=> (Long/valueOf "42")42

Syntactic sugar

Static Fields

user=> (. Math PI)3.141592653589793

user=> Math/PI3.141592653589793

Syntactic sugar

Constructors

user=> (new java.io.File "/home")#<File /home>

user=> (java.io.File. "/home")#<File /home>

Syntactic sugar

Constructorargumentsclass name

Java Import

user=> (import (java.net URL URI))java.net.URIuser=> (URL. "http://clojure.org/")#<URL http://clojure.org/>

Package Classes"prefix list"

try/catch/finally

(try ... expressions ... (catch Class name ... handle exception ...) (finally ... always do this ...))

(throw exception)

throw and *e

user=> (throw (Exception. "Boom!"))Exception Boom! user/eval11 (NO_SOURCE_FILE:5)user=> *e#<RuntimeException java.lang.RuntimeException: java.lang.Exception: Boom!>

constructor

print stack trace

user=> (pst)Exception Boom! user/eval11 (NO_SOURCE_FILE:5) clojure.lang.Compiler.eval (Compiler.java:6424) clojure.lang.Compiler.eval (Compiler.java:6390) clojure.core/eval (core.clj:2795) clojure.main/repl/read-eval-print--5967 (main.clj:244)

defined in clojure.repl

Java Interop Summary

Special Form Sugar

Instance Method

Instance Field

Static Method

Static Field

Constructor

(. obj method args*) (.method obj args*)

(. obj field) (.field obj)

(. Class method args*) (Class/method args*)

(. Class field) Class/field

(new Class args*) (Class. args*)

Java Nested Classes

Package-QualifiedClass Name

UnqualifiedClass Name

Regular Class

Inner Class

java.io.File File

java.util.Map$Entry Map$Entry

Libraries

Java Classpath

Clojure source code in ./src/JAR files in ./lib/

java -cp src:lib/* clojure.main

classpath

Project Management

• Leiningen

• Cake

• Maven

• Ant

MavenDirectory Structure

pom.xmlsrc/main/clojure/ your/project/file.cljsrc/test/clojure/ your/project/file_test.cljtarget/classes/ compiled_file.class$HOME/.m2/repository/ org/clojure/clojure/1.3.0/clojure-1.3.0.jar

LeiningenDirectory Structure

project.cljsrc/ your/project/file.cljtest/ your/project/file_test.cljclasses/ compiled_file.classlib/ clojure-1.3.0.jar

Leiningen project.clj

(defproject my.project.name "1.0.0" :description "My cool Clojure project." :dependencies [[org.clojure/clojure "1.3.0"] [org.clojure/data.zip "0.1.0"]])

groupId artifactId version

Leiningen Commands$ lein helpLeiningen is a build tool for Clojure.

Several tasks are available: pom help jar test deps ... repl new

Run lein help $TASK for details.See http://github.com/technomancy/leiningen as well.

Finding Dependencies

• search.maven.org

• jarvana.com

• clojars.org

clojure-contribup to 1.2

• One big library

• Version number matches Clojure

• Mixed quality

Clojureclojure-contrib

1.0.0 1.0.0

1.1.0 1.1.0

1.2.01.2.1 1.2.0

clojure-contribafter 1.2

• Many small libraries

• Independent version numbers

• Compatible withClojure 1.2 and 1.3

• Mixed quality

algo.monadscore.incubator

core.logiccore.match

core.unifydata.csv

data.finger-treedata.json

data.priority-mapdata.xmldata.zip

java.classpathjava.datajava.jdbcjava.jmx

math.combinatoricsmath.numeric-tower

test.generativetools.cli

tools.loggingtools.macro

tools.namespacetools.nrepltools.tracedev.clojure.org/display/doc/Clojure+Contrib

Included in Clojure• clojure.inspector

• clojure.java.io

• clojure.java.browse

• clojure.java.shell

• clojure.reflect

• clojure.repl

• clojure.string

• clojure.set

• clojure.test

• clojure.walk

• clojure.xml

• clojure.zip

Namespaces

The REPL

user=> (+ 1 2 3)6user=>

"you arehere"

Namespaces

user=> (ns my.cool.thing)nilmy.cool.thing=>

"you are here"

Qualified Symbols

user=> (ns foo.bar)nilfoo.bar=> (defn hello [] (println "Hello, World!"))#'foo.bar/hellofoo.bar=> (ns baz.quux)nilbaz.quux=> (foo.bar/hello)Hello, World!nil

Namespace-qualifiedsymbol

Namespaces and Files

$CLASSPATH/my/cool/thing.clj

(ns my.cool.thing)

dots become slashes

Names and Hyphens

$CLASSPATH/my/cool/web_app.clj

(ns my.cool.web-app)

hyphens become underscores

Macro: ns

(ns name references*)

ns :require

(ns my.cool.project (:require [some.ns.foo :as foo]))

(foo/function-in-foo)

ns alias

ns :use

(ns my.cool.project (:use [some.ns.foo :only (a b)]))

(a)(b) list of

symbols

unqualifiedsymbols

ns :use

(ns my.cool.project (:use some.ns.foo))

(a)(b)

unqualified symbolsfrom anywhere

ns :import

(ns my.cool.project (:import (java.io File Writer))

packagename

classnames

Macro: ns

(ns name (:require [some.ns.foo :as foo] [other.ns.bar :as bar]) (:use [this.ns.baz :only (a b c)] [that.ns.quux :only (d e f)]) (:import (java.io File FileWriter) (java.net URL URI))

require in the REPL

user=> (require '[clojure.set :as set])niluser=> (set/union #{1 2} #{2 3 4})#{1 2 3 4}

arguments mustbe quoted

use in the REPL

user=> (use 'clojure.string)WARNING: replace already refers to: #'clojure.core/replace in namespace: user, being replaced by: #'clojure.string/replaceWARNING: reverse already refers to: #'clojure.core/reverse in namespace: user, being replaced by: #'clojure.string/reverseniluser=> (reverse "hello")"olleh"

arguments mustbe quoted

RELP Helpers: dir

user=> (dir clojure.repl)aproposdemungedirdir-fndocfind-docpstroot-causeset-break-handler!sourcesource-fnstack-element-strthread-stoppernil

Concurrency

Parallelism

class Invoice { private Date date;

public Date getDate() { return this.date; }

public void setDate(Date date) { this.date = date; }}

class Date { public void setDay(int day); public void setMonth(int month); public void setYear(int year);}

Mutable!

public Date getDate() { return this.date; }

public void setDate(Date date) { this.date = date; }}

Better notchange it!

public Date getDate() { return this.date.clone(); }

public void setDate(Date date) { this.date = date.clone(); }}

Defensivecopying

Programming with immutable values

means never having to say you're sorry.

Sept 18

Sept 18 Sept 19

Sept 18

Identity

Sept 19

Value Value

Sept 18

Identity

Sept 19

function

Value Value

function

Sept 18

Identity

Sept 19Sept 17 function

Present Future

function

Sept 18

Identity

Sept 19Sept 17 function

Present Future

function

The future is a function of the past.

Mutable References

Ref Atom

Var Agent

readers

Atomwriter

writer

abortretry

Atom(def tick (atom 1))(deref tick) 1

(swap! tick inc)@tick 2

(swap! tick + 10)@tick 12

value value value value

identity

identityidentity

value value value value

identity

identityidentity

Refwriter

writer

readers

abortretryRef

transaction

Ref(def A (ref 1))(def B (ref 10))

(dosync (alter A inc) (alter B + 10))

transaction

(dosync (alter A inc) (alter B + 10))

@A 2@B 20

AtomicConsistentIsolatedDurable

Database Transactions

AtomicConsistentIsolated

Clojure Transactions

Agentactionaction

readers

action queue

Agent Thread Pool

Agent(def A (agent 1))

A 1queue

(send A inc)@A 1

A 1inc

(send A inc)@A 1

A 1inc

Varroot

binding

thread-local

binding

thread-local

binding

other threads

Ref Atom

Var Agent

Concurrency

Macros

Lexer/Parser

Characters

AbstractSyntax Tree

Compiler/Interpreter

Clojure Reader

ClojureCompiler

You Characters

Data Structures

Clojure Reader

You Characters

Data Structures

Macros

ClojureCompiler

read-string and eval

user=> (read-string "(println 1 2 3)")(println 1 2 3)

user=> (eval *1)1 2 3nil

Macro: when

(when condition exprs*)

(if condition (do exprs*))

defmacro

(defmacro when [test & body] (list 'if test (cons 'do body)))

name parameters

construct codeto return

macroexpand

user=> (macroexpand '(when a b c d))(if a (do b c d))

quoted expression

expanded result

How to Write a Macro

Form you want to write

Form you wantit to become

functioninput output

How to Write a Macro

;; we want to write: ;; and have it become:(when foo (if foo (dothis) (do (dothat)) (dothis) (dothat))) ;; from core.clj(defmacro when [test & body] (list 'if test (cons 'do body)))

;; use macroexpand to try ituser=> (macroexpand '(when foo (dothis) (dothat)))(if foo (do (dothis) (dothat)))

Macro Expansion

(when a b c d)

Macro: when

(if a (do b c d))

arguments arenot evaluated

syntax-quote

(defmacro when [test & body] `(if ~test (do ~@body)))

syntax-quote unquote splicingunquote

syntax-quote

user=> (def x 5)#'user/xuser=> (def lst '(:a :b :c))#'user/lstuser=> `(x ~x ~lst)(user/x 5 (:a :b :c))user=> `(x ~x ~@lst)(user/x 5 :a :b :c)

gensym

user=> (gensym "foo")foo39user=> (gensym "foo")foo42

user=> `(let [x 1] x)(clojure.core/let [user/x 1] user/x)

user=> `(let [x# 1] x#)(clojure.core/let [x__29__auto__ 1] x__29__auto__)

generatedsymbol

auto-gensymqualified symbolnot allowed here

Recursion

Recursive GCD

user=> (defn gcd [x y] ; x >= y (if (zero? y) x (gcd y (rem x y))))#'user/gcduser=> (gcd 100 35)5user=> (gcd 37 22)1

Recursive GCD

user=> (defn gcd [x y] ; x >= y (if (zero? y) x (gcd y (rem x y))))

tail position

GCD with recur

user=> (defn gcd [x y] ; x >= y (if (zero? y) x (recur y (rem x y))))

tail position

Recursive Fibonacci

user=> (defn fib [n] (cond (zero? n) 0 (= 1 n) 1 :else (+ (fib (dec n)) (fib (- n 2)))))#'user/fibuser=> (fib 10)55user=> (fib 50) ; wait a really long time

Fibaonacci Helper

user=> (defn fib-step [a b n] (if (= 1 n) b (recur b (+ a b) (dec n))))#'user/fib-stepuser=> (defn fib [n] (fib-step 0 1 n))#'user/fibuser=> (fib 50)12586269025

loop / recur

user=> (defn fib [n] (loop [a 0, b 1, i n] (if (= 1 i) b (recur b (+ a b) (dec i)))))#'user/fibuser=> (fib 50)12586269025

loop / recur

(loop [initialization] (if termination-condition return-value (recur updated-variables)))

Clojure

• clojure.org

• clojure.blip.tv

• dev.clojure.org

• groups.google.com/group/clojure

• #clojure on irc.freenode.net

• github.com/relevance/labrepl

• 4clojure.com

• github.com/functional-koans/clojure-koans

Introduction to Clojure - Digital Digressions by Stuart … · Stuart Sierra Relevance, Inc....

Documents

Transcript of Introduction to Clojure - Digital Digressions by Stuart … · Stuart Sierra Relevance, Inc....

Clojure at DataStax: The Long Road From Python to Clojure

ETL in Clojure

Operationalizing Clojure Confidently

Clojure-Java Interop - QCon San Francisco 2018 | … · the plan 2 syntax plumbing Clojure calling Java objects, Clojure style Java calling Clojure design principles simplicity direct

Clojure And Swing

Intro Clojure

Clojure functions v

Spark + Clojure for Topic Discovery - Zalando Tech Clojure/Conj Talk

Clojure by Example · 2015-11-27 · .consulting .solutions .partnership Clojure by Example A practical introduction to Clojure on the JVM

Clojure and AltLaw - Digital Digressions by Stuart Sierra · “System” languages C C++ Smalltalk Common Lisp Java C# “Hosted” languages Perl Python Ruby Groovy Scala Clojure

Clojure slides

The Ideas of Clojure - Things I learn from Clojure

Clojure concurrency

Clojure forbeginners

Storm and Clojure - Clojure Meetup January 2015

Clojure testing with Midje - inovex GmbH · Clojure testing with Midje Author: Tobias Bayer, inovex Subject: clojure, midje, testing Keywords: clojure, midje, testing Created Date:

Clojure noir

Clojure class

Clojure 1a

(first '(Clojure.))