Clojure made simple - Lightning talk

( s im p le
( c lo ju r e ) )

C lo ju r e m a d e
s im p le
Ta l k

Clojure concepts
Encourages Pure Functional approach
- use STM to change state

Functions as first class citizens
- functions as arguments as they return a value

Make JVM interoperation simple
- easy to use your existing Java applications

A better Lisp !
Sensible () usage

Sensible macro names

JVM Interoperability

Which LISP is your wingman ?
Common Lisp Clojure

The dark side of Clojure

( x )


( ( x ) )


( ( ( x ) ) )


( ( ( ( x ) ) ) )


( ( ( ( ( x ) ) ) ) )

...verses non-lisp languages

( ) ==
{ ( ) };

Well nearly....

([] ((())))
==
{ ( {( []) }) };

C o m p a r in g
J a va
w it h
C lo ju r e

It s a ll b y t e c o d e in t h e
e nd ..
Any object in clojure is just a regular java object

A reference type inheriting from:
j ava. l ang. obj ec t

B a s ic
C lo ju r e
S yn ta x

Name-spaces
; Define a namespace
( ns nam s pac e- nam
e- e)

; Include namespace code
( us e ' nam - s pac e- nam
es e)

Groups code together like a package statement
in Java

Defining a function
First principles Syntactic Sugar
( def nam e ( def n nam e
( f n [ ar gs ] [ ar gs ]
( f unc t i on- body ( f unc t i on-
…) )
) body . . . ) )

( def n w c om m s age [ nam ]
el e- es e
( pr i nt l n ( s t r “ W c om t o Cl oj ur e ”
el e
nam )e)

Special forms
Special evaluation rules for the Clojure compiler
- part of the language definition

catch, def, do, dot ('.'), finally, fn, if, let, loop,
monitor-enter, monitor-exit, new, quote,
recur, set!, throw, try and var

Simple function example
Define a simple function

( def n hel l o- w l d [ nam
or e]
( pr i nt l n( s t r " Hel l o "
nam ) )
e)

Call the function in the REPL or in your code
( hel l o- w l d " j r 0c ket " )
or

Prefix notation

( def n s quar e- t he- number
[ x]
( * x x) )

“Overloading” functions

( def n make
([ ] ; do t h e f o l l o wi n g f u n c t i o n i f
n o ar g s

( s t r uc t vec t or 0 0) )
( [ x y] ; d o i f x an d y ar e
ar g u me n t s

( s t r uc t vec t or x y) )
)

Im m u t a b le
D a ta
s truc ture s

List – Ordered collection

( l i s t 1 3 5 7)

' ( 1 3 5 7)

( 1 2 3) ; 1 i s n o t a
f unct i on

Vectors – hashed ordered list
[ : m r i x- c har ac t er s [ : neo
at
: m pheus : t r i ni t y : s m t h] ]
or i

( f i r s t [ : n e o : mo r p h e u s : t r i n i t y
: s mi t h ] )

( nt h [ : mat r i x : b ab yl o n 5 : f i r e f l y
: s t ar g at e ] 2 )

( c onc at [ : n e o ] [ : t r i n i t y] )

Maps – unordered key/values
{ : a 1 : b 2} { : a { : a 1} }
{ : a 1 , : b 2} {: a {: a 1}}

{ :a 1 :b } { { : a 1} : a}
j ava. l an g . Ar r ayI n d e x Ou t Of Bo { { : a 1 } : a}
u n d s Ex c e p t i o n : 3
; i d i om - put : a on t he
left
{ : a 1 : b 2}
{ : a 1 , : b 2}

L is t s a r e f o r
c ode

Ve c t o r s a r e
fo r d a ta

Working with data
(last [1 1 2 3 5 8]) (doc last)

(defn penultimate [x]
(last (butlast x)) ) (doc butlast)

(penultimate [1 2 3 4 5])

And more...
(nth [1 1 2 3 5 8] 2)

(count [1 1 2 3 5 8])

(reverse [1 1 2 3 5 8])

(defn palindrome? [x] Proposition – naming
(= x (reverse x)) ) convention

Even more
(flatten [[1 1] 2 [3 [5 8]]])

(compress "aaaabccaadeeee")

(encode "aaaabccaadeeee")

(replicate 10 "a")

Defining a data structure
( def m dat a- s t r uc t ur e
y-
[ dat a ] )

( def days - of - t he- week
[ “Monday” “ Tues day”
“W ednes day” ] )

Example data structure

( def j r 0c ket
{ : f i r s t - nam " J ohn" ,
e

: l as t - name
" St evens on" } )

c lo ju r e .
org
d o c s . c lo ju r
e .o rg

All hail the REPL
An interactive shell for
clojure

Fast feedback loop
for clojure

M a n a g in g a
c lo ju r e
p r o je c t

Maven
Just like any other Java project

Step 1)
Add Clojure library jar to your POM

Step 2)
Download the Internet !!!

le in in g e n
Leiningen
.o rg

lein new Create a new clojure project
lein deps Download all dependencies
lein repl Start the interactive shell (repl)
lein swank Start repl server

A fe w
in t e r e s t in g
C lo ju r e
e x a m p le s

str
(str h e l l o) Concatenate strings
together
represent a
character using

(def data “boo”) Join arguments with
(str “message” data ) strings

Ratio
Unique data type ( / 3 5)
( / 3. 0
Allow lazy evaluation
5)
Avoid loss of precision
(/ 1 3)
(/ 1.0 3)

(class (/ 1

Calling Java... ooooo!!
( j avax . s wi n g . JOp t i o n Pan e /
s h o wMe s s ag e D i al o g n i l
" He l l o W r l d " )
o

Importing Java into Clojure
( ns dr aw ng- dem
i o
( : i m t [ j avax. s w ng J panel
por i
J Fr am e]
[ j ava. awt
Di m i on] ) )
ens

Working with Java
Java Classes
fullstop after class name
( J Fr am )
e.
(Math/cos 3) ; static method call

Java methods
fullstop before method name
( . get Cont ent Pane f r am ;;method name first
e)
( . f r am get Cont ent Pane) ;;object first
e

What class is that...
(class (str "Jr0cket"))
java.lang.String

(class (defn hello-world [name] (str "Hello
cruel world")))
clojure.lang.Var

Clojure calling Java web stuff
( l et [ c onn]
( dot o ( Ht t pUr l Connec t i on.
Ur l )
( . s et Reques t M hod
et
“ POST” )
( . s et DoOut put t r ue)

( . s et I ns t aneFol l ow Redi r ec t
s t r ue) ) ] )

Recursive functions
Functions that call Tail recursion
themselves Avoids blowing the
stack
Fractal coding
A trick as the JVM does
not support tail
recursion directly :-(

Tail recursion
( def n r ec ur s i ve- c ount er
( pr i nt ans w )er
( i f ( < ans w er 1000)
( r ec ur ( + ans wer 4) ) ) )

Where to find out more...

c l oj ur e. or g/ c heat s h
eet

Software Transactional Memory

Provides safe, concurrent access to memory

Agents allow encapsulated access to mutable
resources

Functional for the web
Big blog of stuff in > Big blob of stuff out

Encourages modularising responsibilities

Good at processing data in parallel

M o re to
c o m e ...
c l oj ur e. or g
dev. c l oj ur e. or g

@ r 0c ket
j
c l oj ur e. j r 0c ket . c o

Clojure made simple - Lightning talk

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Clojure made simple - Lightning talk

Similaire à Clojure made simple - Lightning talk (20)

Plus de John Stevenson

Plus de John Stevenson (20)

Dernier

Dernier (20)

Clojure made simple - Lightning talk

Notes de l'éditeur