Clojure

1
Clojure

• Lisp Reloaded

2
Versions of LISP

• Lisp is an old language with many variants
• LISP is an acronym for List Processing language
• Lisp is alive and well today
• Most modern versions are based on Common Lisp
• Scheme is one of the major variants
• Clojure is the latest in a long line of dialects
• Clojure uses a new approach to concurrency,
  Software Transactional Memory (STM)

3
Lisp syntax vs. Clojure syntax
4
Basic data types I

• Numbers Clojure has integers, floating point
  numbers, and ratios
• Integers include decimal integers (255), octals
  numbers (012), hexadecimal numbers (0xff) and
  radix numbers (2r1111), where the radix is an
  integer between 2 and 36, inclusive
• Floating point numbers include standard notation
  (3.1416) and scientific notation(1.35e-12).
• Ratios are fractions such as 1/3 they are not
  subject to roundoff error
• Strings are enclosed in double quotes, and can
  contain escaped characters
• Within a string, \n represents a newline, as
  usual
• Character literals are written as \c to indicate
  the character c
• Since \n represents the character n, \newline is
  used to represent a newline
• Keywords are not reserved words, but are like
  atoms in Prolog or Erlang a keyword begins
  with a colon (foo) and stands for itself

5
Basic data types II

• A list is a sequence of values enclosed in
  parentheses, for example, (one 2 "buckle my
  shoe")
• Elements of the list are separated by whitespace
  or commas
• A list represents either data or a function call,
  depending on context
• A vector is a sequence of values enclosed in
  brackets, for example, one 2 "buckle my shoe
• Elements of the vector are separated by
  whitespace or commas
• A map or hash is a sequence of key/value pairs,
  enclosed in braces, for example,ace 1, deuce
  2, "trey" 3
• Elements are separated by whitespace or commas
• It is helpful to use commas between key/value
  pairs
• A set is a pound sign () followed sequence of
  values enclosed in braces, for example a b c

6
Functions

• The syntax to define a named function is(defn
  function_name arguments expressions)
• The value of the function is the value of the
  last expression evaluated
• The syntax of a function call is(function_name
  arguments)
• Notice that the name of the function being called
  is the first thing inside the parentheses
• The syntax of an anonymous function, or lambda,
  is (fn arguments expressions)
• This syntax can be used in place of a function
  name
• Example ((fn lst (first lst)) my-list) is
  equivalent to (first my-list)
• Since functions are first-class values, this
  syntax is convenient for creating a function to
  be used as an argument to another function

7
Sequences

• Lists, vectors, maps, and sets are all
  sequences, and many of the same operations
  apply
• (first seq) returns the first element of seq
• If the seq is empty, the empty list, (), is
  returned
• (rest seq) returns the seq without its first
  element
• If the seq is empty, the empty list, (), is
  returned
• (cons value seq) returns a sequence of the same
  type with the value inserted as the new first
  element

8
Fast and slow operations

• Sequence is an interface roughly analogous to
  Java's Iterator
• It is a small interface (a couple of methods)
  that can be applied to a large range of data
  types
• Many (most?) of the common Clojure operations are
  defined on sequences
• For example, map and reduce work across almost
  all data types.
• Clojure.org describes sequences as logical
  lists
• The primary sequence operations are first, rest
  and cons
• Everything else is built around these
  operations.
• The set of cheap (constant time) operations are
  the same as for lists Add/remove/access the
  first element or iterate over all elements
• Operations like nth and last are expensive (O(n)
  time) since they must traverse the entire list.
• Unlike lists, count - getting the length of a
  sequence - is also expensive.

9
Sequence operations

• Sequence operations can be used on almost any
  compound type
• Collections Vector, list, map, set, struct
• Strings (as char sequence)
• Java arrays, collections, sets, maps, iterator,
  enumerable
• IO streams
• Producer functions Many lazy seqs do not get
  their values from a backing data set, but from a
  function that calculates the value when asked
  for.
• Some collections can be used directly as
  sequences, others need to be converted
• The rules are somewhat different for different
  kinds of collections, so the simplest general
  strategy is to
• convert to sequence
• do the processing
• if you need a particular non-sequence type (like
  vector or array), convert the return value back

10
Predicates

• A predicate (in any computer language) is a
  function that returns either true or false
• In Clojure,
• false is one of the atoms false or nil
• true is the atom true
• In addition, anything that isnt false or nil is
  considered to be true
• In particular, the empty list, (), is true
• Hence, a predicate returns either false, nil, or
  any other value to mean true
• Predicates often return true values other than
  true, especially if the returned value might be
  useful

11
Function calls and data

• A function call is written as a list
• The first element is the name of the function
• Remaining elements are the arguments
• Example (println "Hello" "World")
• Calls function println with arguments "Hello" and
  "World
• The function prints Hello World and returns nil
• Data is written as atoms or lists
• Example (println "Hello" "World") is a list of
  three elements
• Do you see a problem here?

12
Quoting

• Is (f a b) a call to f, or is it just data?
• All literal data must be quoted (atoms, too)
• Exceptions include nil, true, and nil, which do
  not need to be quoted
• x indicates the variable x, while (quote x) is
  just x
• (quote (f a b)) is the list (f a b)
• quote is not a function, but a special form
• The special form gets the unevaluated arguments,
  and is control of when or whether to evaluate
  them
• Special forms, unlike functions, are not
  first-class values
• '(f a b) is a shorthand way of doing the same
  thing
• There is just one single quote at the beginning
• It quotes one expression

13
Examples

• (defn my-first x (first x))
• usergt (my-first '(1 2 3))1
• defn my-second lst (first (rest lst)))
• usergt (my-second '(a b c))b

• (defn my-third "This is a doc comment"
  lst (first (rest (rest lst))) )
• usergt (my-third "Whatever")\a
• usergt (doc my-third)-------------------------us
  er/my-third(lst) This is a doc commentnil

14
Arithmetic

• Returns the sum of its arguments () returns
  0
• - Subtracts the rest of the numbers from the
  first number
• Returns the product of its arguments()
  returns 1.
• / Divides the rest of the numbers into the first
  number
• If operands are integers, result is a ratio
• If only one number, returns its inverse
• quot Returns the quotient of integer division
  of the first number by the rest of the numbers
• rem remainder of dividing the first number by
  the second
• mod Modulus of first and second number truncates
  toward negative infinity
• inc Returns a number one greater than its
  argument
• dec Returns a number one less than its argument
• max Returns the largest of its arguments
• min Returns the smallest of its arguments

15
Numeric comparisons

• Returns true if all arguments are equal
• This is a true equality test, not an identity
  test
• Collections are compared in a type-independent
  manner for example,( '(1 2 3) '1 2 3)
  returns true
• Returns true if numeric arguments all have
  the same value, otherwise false
• not Same as (not ( obj1 obj2))
• lt Returns true if numeric arguments are in
  monotonically increasing order
• gt Returns true if numeric arguments are in
  monotonically decreasing order, otherwise false
• lt Returns true if numeric arguments are in
  monotonically non-decreasing order, otherwise
  false
• gt Returns true if numeric arguments are in
  monotonically non-increasing order, otherwise
  false

16
Conditional execution

• if is a special form that takes exactly three
  arguments
• A predicate
• An expression to evaluate if the predicate is
  true
• An expression to evaluate if the predicate is
  false
• Syntax (if predicate true-branch
  false-branch)
• Example(defn sum lst (if ( lst ())
  0 ( (first lst) (sum (rest lst))) )
  )(defn average lst (/ (sum lst) (count
  lst)) )

17
The problem with if

• if expressions nest rather awkwardly
• (defn collatz n (println n) (if ( n
  1) 1 (if ( (rem n 2) 0)
  (collatz (/ n 2)) (collatz (inc (
  3 n))) ) ) )
• In most cases, the more general cond is preferred

18
cond

• cond implements the if...then...elseif...then...e
  lseif...then... control structure
• Like if, cond is a special form, not a function
• That is, the arguments to cond are not evaluated
  before cond is called rather, cond evaluates the
  arguments as it pleases

19
Syntax of the cond

• The syntax of the cond special form is(cond
  condition result condition result ...)
• Example
• (defn pos-neg-or-zero "Determines whether n is
  positive, negative, or zero" n (cond (lt
  n 0) "negative" (gt n 0) "positive" else
  "zero"))
• The last condition, else, is true, and reads
  better than the atom true

20
Rules for Recursion

• Handle the base (simplest) cases first
• Recur only with a simpler case
• Simpler more like the base case
• Dont alter global variables
• Dont look down into the recursion

21
Example member

• As an example we define member, to test
  membership in a list
• (defn member a lat (cond (empty?
  lat) false ( a (first lat)) true
  else (member a (rest lat)) ) )
• usergt (member b '(a b c))true

22
Guidelines for recursive Clojure functions

• Unless the function is trivial, use a cond
• Handle the base case(s) first
• Avoid having more than one base case
• The base case is often testing for an empty list
• Do something with the first and recur with the
  rest
• Use tail recursion wherever possible

23
Example union

• (defn union set1 set2 (cond (empty?
  set1) set2 (member (first set1) set2)
  (union (rest set1) set2) else (cons
  (first set1) (union (rest set1) set2)) ) )
• This example uses the previously defined member
  function
• It appears that, if function A calls function B,
  Clojure requires function B to be defined before
  defining function A
• Of all the languages I have used, only C and its
  variants make this requirement
• Unless Im missing something, this is a real step
  backward for Lisp dialects

24
Tests

• nil? Returns true if x is nil, false otherwise.
• identical? Tests if 2 arguments are the same
  object
• zero? Returns true if num is zero, else false
• pos? Returns true if num is greater than
• neg? Returns true if num is less than zero,
  else false
• even? Returns true if n is even, throws an
  exception if n is not an integer
• odd? Returns true if n is odd, throws an
  exception if n is not an integer

25
Type tests

• coll? Returns true if x implements
  IPersistentCollection
• seq? Return true if x implements ISeq
• vector? Return true if x implements
  IPersistentVector
• list? Returns true if x implements
  IPersistentList
• map? Return true if x implements IPersistentMap
• set? Returns true if x implements IPersistentSet

26
Content Tests

• contains? Returns true if key is present in the
  given collection, else false
• distinct? Returns true if no two of the
  arguments are
• empty? Returns true if coll has no items - same
  as (not (seq coll))
• Use the idiom (seq x) rather than (not (empty?
  x))
• every? Returns true if (pred x) is logical true
  for every x in collection, else false
• not-every? Returns false if (pred x) is logical
  true for every x in collection, else true
• some Returns the first logical true value of
  (pred x) for any x in collection
• not-any? Returns false if (pred x) is logical
  true for any x in collection, else true

27
I/O

• in A java.io.Reader object representing
  standard input for read operations
• out A java.io.Writer object representing
  standard output for print operations
• err A java.io.Writer object representing
  standard error for print operations
• print Prints the object(s) to the output stream
  that is the current value of out
• printf Prints formatted output, as per format
• println Same as print followed by (newline)
• pr Prints the object(s) to the output stream
  that is the current value of out
• prn Same as pr followed by (newline). Observes
  flush-on-newline
• newline Writes a newline to the output stream
  that is the current value of out
• read-line Reads the next line from stream that is
  the current value of in
• slurp Reads the file into a string and returns
  it
• spit Opposite of slurp. Opens file with writer,
  writes content, then closes it

28
REPL commands

• (load-file filename) loads a file containing
  Clojure functions
• 1 bound in a repl thread to the most recent
  value printed
• 2 bound in a repl thread to the second most
  recent value printed
• 3 bound in a repl thread to the third most
  recent value printed
• e bound in a repl thread to the most recent
  exception caught by the repl
• print-dup When set to logical true, objects
  will be printed in a way that preserves their
  type when read in later
• print-length controls how many items of each
  collection the print
• print-level controls how many levels deep the
  printer will print
• print-meta If set to logical true, when
  printing an object, its metadata will also be
  printed in a form that can be read back by the
  reader
• print-readably When set to logical false,
  strings and characters will be printed with
  non-alphanumeric characters converted to the
  appropriate escape sequences

29
Dealing with the REPL

• Clojures REPL (Read-Eval-Print Loop) seems to be
  very buggy
• I get a lot of errors along these
  linesjava.lang.Exception Unable to resolve
  symbol union in this context (NO_SOURCE_FILE43)
• (Its a Java exception because Clojure is
  compiled to the JVM)
• Here are two workarounds that seem to solve most
  such problems
• Start a new Clojure shell, or
• Just copy the function definition and paste it
  directly into the Clojure shell

30
The End