My first significant crack at Clojure – a simple implementation of Conway’s game of life.

(defn UpdateWorld
 "Takes a list of lists representing the world state, and
 generates a new one"
 [worldState]

 (defn cellOn
  "Checks to see if the given cell exists and is on"
  [x y]
   (let [maxSize (- (count (first worldState)) 1)]
    ; If the cell is within the bounds of the world, and is turned on
    (if (and (>= x 0) (= y 0) (<= y maxSize) (nth (nth worldState y) x))
     true
     false)))

 (defn countNeighbours
  "Counts the number of neighbours the given cell has"
  [x y]
   ; Loop through y direction
   (loop [yIdx (- y 1) neighbours 0]
    ; Loop through x direction and store count of on cells into rowCount
    (let [rowCount
     (loop [xIdx (- x 1) rowCount 0]
      ; If the cell is on and isn't the cell we are counting neighbours for
      (if (and (cellOn xIdx yIdx) (not (and (= x xIdx) (= y yIdx))))
       ; If the next iteration is still in the row
       (if (< xIdx (+ x 1))
        ; Increment the x position and the row count
        (recur (+ xIdx 1) (+ rowCount 1))
        ; Return the row count
        (+ rowCount 1))
       ; If the next iteration is still in the row
       (if (< xIdx (+ x 1))
        ; Increment the x position
        (recur (+ xIdx 1) rowCount)
        ; Return the row count
        rowCount)))]
     ; If the next iteration is still a valid column
     (if (< yIdx (+ y 1))
      ; Increment the y position and the neighbour count and loop
      (recur (+ yIdx 1) (+ neighbours rowCount))
      ; Return
      (+ neighbours rowCount))
    )))

 (defn updateCell
  "Checks to see if the given cell is alive, by counting its neighbours"
  [xy]
   (let [x (first xy) y (nth xy 1) neighbours (countNeighbours x y)]
    (if (nth (nth worldState y) x)
     ; Apply the cell already alive rules
     (if ( dies
      false
      (if ( lives
       true
       ; Alive and more than three neighbours => dies
       false))
     (if (= neighbours 3)
      ; Dead and exactly three neighbours lives => lives
      true
      false))))

 (defn updateRow
  "Maps an old row to a new row. Generate
  a list of (x y) pairs and map them through updateCell
  to produce the new row."
  [y]
   (let [rowWidth (count (nth worldState y))]
    (map updateCell
     (map
      (fn [x] (list x y))
      (range 0 rowWidth)))))
 ; Update each row
 (map updateRow (range 0 (count worldState))))