Some Clojure code from class, for testing primality, in a Gorilla REPL worksheet. View: http://viewer.gorilla-repl.org/view.html?source=gist&id=766a20c30fb54f009e4e8a38173a4910

primes.clj

;; gorilla-repl.fileformat = 1

;; **
;;; # Primes
;; **

;; @@
(ns primes)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-nil'>nil</span>","value":"nil"}
;; <=

;; @@
(mod 23 5)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-long'>3</span>","value":"3"}
;; <=

;; @@
(mod 24 5)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-long'>4</span>","value":"4"}
;; <=

;; @@
(mod 25 5)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-long'>0</span>","value":"0"}
;; <=

;; @@
(defn evenly-divides? [n m]
  "Returns true if n evenly divides m, or false otherwise."
  (= 0 (mod m n)))
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-var'>#&#x27;primes/evenly-divides?</span>","value":"#'primes/evenly-divides?"}
;; <=

;; @@
(evenly-divides? 4 21)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-unkown'>false</span>","value":"false"}
;; <=

;; @@
(evenly-divides? 4 20)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-unkown'>true</span>","value":"true"}
;; <=

;; @@
(range 1 11)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-unkown'>(1 2 3 4 5 6 7 8 9 10)</span>","value":"(1 2 3 4 5 6 7 8 9 10)"}
;; <=

;; @@
(filter odd? (range 1 11))
;; @@
;; =>
;;; {"type":"list-like","open":"<span class='clj-lazy-seq'>(</span>","close":"<span class='clj-lazy-seq'>)</span>","separator":" ","items":[{"type":"html","content":"<span class='clj-long'>1</span>","value":"1"},{"type":"html","content":"<span class='clj-long'>3</span>","value":"3"},{"type":"html","content":"<span class='clj-long'>5</span>","value":"5"},{"type":"html","content":"<span class='clj-long'>7</span>","value":"7"},{"type":"html","content":"<span class='clj-long'>9</span>","value":"9"}],"value":"(1 3 5 7 9)"}
;; <=

;; @@
(filter #(evenly-divides? % 10)
        (range 1 11))
;; @@
;; =>
;;; {"type":"list-like","open":"<span class='clj-lazy-seq'>(</span>","close":"<span class='clj-lazy-seq'>)</span>","separator":" ","items":[{"type":"html","content":"<span class='clj-long'>1</span>","value":"1"},{"type":"html","content":"<span class='clj-long'>2</span>","value":"2"},{"type":"html","content":"<span class='clj-long'>5</span>","value":"5"},{"type":"html","content":"<span class='clj-long'>10</span>","value":"10"}],"value":"(1 2 5 10)"}
;; <=

;; @@
(defn factors [n]
  "Returns all of the factors of integer n."
  (filter #(evenly-divides? % n)
          (range 1 (inc n))))
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-var'>#&#x27;primes/factors</span>","value":"#'primes/factors"}
;; <=

;; **
;;; The following version uses the full anonymous function syntax, rather that the "shortcut" syntax, but does the same thing:
;; **

;; @@
(defn factors [n]
  "Returns all of the factors of integer n."
  (filter (fn [i] (evenly-divides? i n))
          (range 1 (inc n))))
;; @@

;; @@
(factors 10)
;; @@
;; =>
;;; {"type":"list-like","open":"<span class='clj-lazy-seq'>(</span>","close":"<span class='clj-lazy-seq'>)</span>","separator":" ","items":[{"type":"html","content":"<span class='clj-long'>1</span>","value":"1"},{"type":"html","content":"<span class='clj-long'>2</span>","value":"2"},{"type":"html","content":"<span class='clj-long'>5</span>","value":"5"},{"type":"html","content":"<span class='clj-long'>10</span>","value":"10"}],"value":"(1 2 5 10)"}
;; <=

;; @@
(factors 11)
;; @@
;; =>
;;; {"type":"list-like","open":"<span class='clj-lazy-seq'>(</span>","close":"<span class='clj-lazy-seq'>)</span>","separator":" ","items":[{"type":"html","content":"<span class='clj-long'>1</span>","value":"1"},{"type":"html","content":"<span class='clj-long'>11</span>","value":"11"}],"value":"(1 11)"}
;; <=

;; @@
(factors 453987)
;; @@
;; =>
;;; {"type":"list-like","open":"<span class='clj-lazy-seq'>(</span>","close":"<span class='clj-lazy-seq'>)</span>","separator":" ","items":[{"type":"html","content":"<span class='clj-long'>1</span>","value":"1"},{"type":"html","content":"<span class='clj-long'>3</span>","value":"3"},{"type":"html","content":"<span class='clj-long'>9</span>","value":"9"},{"type":"html","content":"<span class='clj-long'>73</span>","value":"73"},{"type":"html","content":"<span class='clj-long'>219</span>","value":"219"},{"type":"html","content":"<span class='clj-long'>657</span>","value":"657"},{"type":"html","content":"<span class='clj-long'>691</span>","value":"691"},{"type":"html","content":"<span class='clj-long'>2073</span>","value":"2073"},{"type":"html","content":"<span class='clj-long'>6219</span>","value":"6219"},{"type":"html","content":"<span class='clj-long'>50443</span>","value":"50443"},{"type":"html","content":"<span class='clj-long'>151329</span>","value":"151329"},{"type":"html","content":"<span class='clj-long'>453987</span>","value":"453987"}],"value":"(1 3 9 73 219 657 691 2073 6219 50443 151329 453987)"}
;; <=

;; @@
(some odd? [2 4 6 7 8])
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-unkown'>true</span>","value":"true"}
;; <=

;; @@
(some odd? [2 4 6 8])
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-nil'>nil</span>","value":"nil"}
;; <=

;; @@
(defn prime? [n]
  "Returns true if integer n is prime, or false otherwise."
  (not (some #(and (not= % 1) (not= % n))
             (factors n))))
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-var'>#&#x27;primes/prime?</span>","value":"#'primes/prime?"}
;; <=

;; @@
(prime? 88)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-unkown'>false</span>","value":"false"}
;; <=

;; @@
(prime? 89)
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-unkown'>true</span>","value":"true"}
;; <=

;; **
;;; Because we've used lazy sequences, this isn't always as inefficient as you might suspect, although lazy sequence processing is "chunked". We can demonstrate this by redefining `evenly-divides?` to print the value that it is checking.
;; **

;; @@
(defn evenly-divides? [n m]
  "Returns true if n evenly divides m, or false otherwise."
  (println "Checking" n)
  (= 0 (mod m n)))
;; @@
;; =>
;;; {"type":"html","content":"<span class='clj-var'>#&#x27;primes/evenly-divides?</span>","value":"#'primes/evenly-divides?"}
;; <=

;; @@
(prime? 48788)
;; @@
;; ->
;;; Checking 1
;;; Checking 2
;;; Checking 3
;;; Checking 4
;;; Checking 5
;;; Checking 6
;;; Checking 7
;;; Checking 8
;;; Checking 9
;;; Checking 10
;;; Checking 11
;;; Checking 12
;;; Checking 13
;;; Checking 14
;;; Checking 15
;;; Checking 16
;;; Checking 17
;;; Checking 18
;;; Checking 19
;;; Checking 20
;;; Checking 21
;;; Checking 22
;;; Checking 23
;;; Checking 24
;;; Checking 25
;;; Checking 26
;;; Checking 27
;;; Checking 28
;;; Checking 29
;;; Checking 30
;;; Checking 31
;;; Checking 32
;;; 
;; <-
;; =>
;;; {"type":"html","content":"<span class='clj-unkown'>false</span>","value":"false"}
;; <=

;; **
;;; This didn't have to generate and look at all of the factors of 48788, because the sequences created by `range` and `filter` are lazy, and as soon as you get to 2 you know that there's some factor that's not 1 or 48788. However, it did go past 2 because lazy sequences are "realized" in chunks of 32 elements.
;; **