Refactor code to use Clojure idioms for clarity

bb.edn

@@ -1,16 +1,16 @@
-{:tasks {test               (shell "clojure -X:test")
-         lint               (do (run 'style:cljfmt)
-                                (run 'style:cljstyle)
-                                (run 'lint:eastwood)
-                                (run 'lint:kondo))
-         style:fix          (do (run 'style:fix:cljfmt)
-                                (run 'style:fix:cljstyle))
-         style:cljfmt       (shell "cljfmt check")
-         style:cljstyle     (shell "cljstyle check")
-         style:fix:cljfmt   (shell "cljfmt fix")
-         style:fix:cljstyle (shell "cljstyle fix")
-         lint:eastwood      (shell "clojure -M:test:eastwood")
-         lint:kondo         (shell "clj-kondo --lint test src")
-         pre-push           (do (run 'style:fix)
-                                (run 'test)
-                                (run 'lint))}}
+{:tasks {test           (shell "clojure -X:test")
+         lint           (do (run 'style:cljfmt)
+                            (run 'style:cljstyle)
+                            (run 'lint:eastwood)
+                            (run 'lint:kondo))
+         fix            (do (run 'fix:cljfmt)
+                            (run 'fix:cljstyle))
+         style:cljfmt   (shell "cljfmt check")
+         style:cljstyle (shell "cljstyle check")
+         fix:cljfmt     (shell "cljfmt fix")
+         fix:cljstyle   (shell "cljstyle fix")
+         lint:eastwood  (shell "clojure -M:test:eastwood")
+         lint:kondo     (shell "clj-kondo --lint test src")
+         pre-push       (do (run 'style:fix)
+                            (run 'test)
+                            (run 'lint))}}

src/sicp/chapter_2/part_1/book_2_1.clj

@@ -94,7 +94,7 @@
   [x y]
   (let [dispatch (fn [m]
                    (cond
-                     (= m 0) x
+                     (zero? m) x
                      (= m 1) y
                      :else (throw (Exception. "Argument not 0 or 1: CONS"))))]
     dispatch))

src/sicp/chapter_2/part_1/ex_2_01.clj

@@ -11,8 +11,8 @@
 (defn make-rat-2
   [numer denom]
   (let [devider      (abs (m/gcd numer denom))
-        signed-numer (cond (and (< denom 0) (< numer 0)) (abs numer)
-                           (and (< denom 0) (> numer 0)) (- numer)
+        signed-numer (cond (and (neg? denom) (neg? numer)) (abs numer)
+                           (and (neg? denom) (pos? numer)) (- numer)
                            :else numer)
         signed-denom (abs denom)]
     (m/pair (/ signed-numer devider)

src/sicp/chapter_2/part_1/ex_2_03.clj

@@ -15,12 +15,10 @@
 
 (defn length-segment
   [segment]
-  (Math/sqrt (+ (Math/pow (- (ex-2-02/x-point (ex-2-02/start-segment segment))
-                             (ex-2-02/x-point (ex-2-02/end-segment segment)))
-                          2)
-                (Math/pow (- (ex-2-02/y-point (ex-2-02/start-segment segment))
-                             (ex-2-02/y-point (ex-2-02/end-segment segment)))
-                          2))))
+  (Math/hypot (- (ex-2-02/x-point (ex-2-02/start-segment segment))
+                 (ex-2-02/x-point (ex-2-02/end-segment segment)))
+              (- (ex-2-02/y-point (ex-2-02/start-segment segment))
+                 (ex-2-02/y-point (ex-2-02/end-segment segment)))))
 
 (defn make-rectangle
   [segment-width segment-height]

src/sicp/chapter_2/part_1/ex_2_06.clj

@@ -22,7 +22,7 @@
 ; (not in terms of repeated application of add-1).
 
 (def zero (fn [_] (fn [x] x)))
-(def one (fn [f] (fn [x] (f x))))
+(def one (fn [f] f))
 (def two (fn [f] (fn [x] (f (f x)))))
 
 (defn add-1

src/sicp/chapter_2/part_1/ex_2_10.clj

@@ -9,9 +9,7 @@
 
 (defn div-interval
   [interval-1 interval-2]
-  (if (< (* (m/lower-bound interval-2)
-            (m/upper-bound interval-2))
-         0)
+  (if (neg? (* (m/lower-bound interval-2) (m/upper-bound interval-2)))
     (m/error "interval-2 is spanning zero")
     (m/mul-interval
       interval-1

src/sicp/chapter_2/part_1/ex_2_11.clj

@@ -51,8 +51,8 @@
 
 (defn interval-case
   [low high]
-  (cond (and (< low 0) (< high 0)) -1
-        (and (< low 0) (> high 0)) 0
+  (cond (and (neg? low) (neg? high)) -1
+        (and (neg? low) (pos? high)) 0
         :else 1))
 
 (defn mul-interval
@@ -68,21 +68,21 @@
                        ; - - - -
                        (= i2-case -1) (m/make-interval (* i1-hi i2-hi) (* i1-lo i2-lo))
                        ; - - - +
-                       (= i2-case 0) (m/make-interval (* i1-lo i2-hi) (* i1-lo i2-lo))
+                       (zero? i2-case) (m/make-interval (* i1-lo i2-hi) (* i1-lo i2-lo))
                        ; - - + +
                        :else (m/make-interval (* i1-lo i2-hi) (* i1-hi i2-lo)))
-      (= i1-case 0) (cond
-                      ; - + - -
-                      (= i2-case -1) (m/make-interval (* i1-hi i2-lo) (* i1-lo i2-lo))
-                      ; - + - +
-                      (= i2-case 0) (m/make-interval (min (* i1-lo i2-hi) (* i1-hi i2-lo))
-                                                     (max (* i1-lo i2-lo) (* i1-hi i2-hi)))
-                      ; - + + +
-                      :else (m/make-interval (* i1-lo i2-hi) (* i1-hi i2-hi)))
+      (zero? i1-case) (cond
+                        ; - + - -
+                        (= i2-case -1) (m/make-interval (* i1-hi i2-lo) (* i1-lo i2-lo))
+                        ; - + - +
+                        (zero? i2-case) (m/make-interval (min (* i1-lo i2-hi) (* i1-hi i2-lo))
+                                                         (max (* i1-lo i2-lo) (* i1-hi i2-hi)))
+                        ; - + + +
+                        :else (m/make-interval (* i1-lo i2-hi) (* i1-hi i2-hi)))
       :else (cond
               ; + + - -
               (= i2-case -1) (m/make-interval (* i1-hi i2-lo) (* i1-lo i2-hi))
               ; + + - +
-              (= i2-case 0) (m/make-interval (* i1-hi i2-lo) (* i1-hi i2-hi))
+              (zero? i2-case) (m/make-interval (* i1-hi i2-lo) (* i1-hi i2-hi))
               ; + + + +
               :else (m/make-interval (* i1-lo i2-lo) (* i1-hi i2-hi))))))

src/sicp/chapter_2/part_2/book_2_2.clj

@@ -33,8 +33,8 @@
 (defn list-ref
   [lst index]
   (cond
-    (< index 0) nil
-    (= index 0) (first lst)
+    (neg? index) nil
+    (zero? index) (first lst)
     :else (list-ref (rest lst) (dec index))))
 
 (comment
@@ -45,15 +45,15 @@
   [items]
   (if (m/list-empty? items)
     0
-    (+ 1 (length-recursice (m/cdr items)))))
+    (inc (length-recursice (m/cdr items)))))
 
 (comment
   (length-recursice (list 1 3 5 7)))                        ; 4
 
 (defn length
   [list]
   (if (seq list)
-    (+ 1 (length (rest list)))
+    (inc (length (rest list)))
     0))
 
 (comment
@@ -71,21 +71,14 @@
 
 (defn scale-list
   [items factor]
-  (if (m/list-empty? items)
-    nil
-    (cons (* (m/car items) factor)
-          (scale-list (m/cdr items)
-                      factor))))
+  (when-not (m/list-empty? items) (cons (* (m/car items) factor) (scale-list (m/cdr items) factor))))
 
 (comment
   (scale-list (list 1 2 3 4 5) 10))                         ; (10 20 30 40 50)
 
 (defn my-map
   [proc items]
-  (if (m/list-empty? items)
-    nil
-    (cons (proc (m/car items))
-          (my-map proc (m/cdr items)))))
+  (when-not (m/list-empty? items) (cons (proc (m/car items)) (my-map proc (m/cdr items)))))
 
 (comment
   (my-map abs (list -10 2.5 -11.6 17))                      ; (10 2.5 11.6 17)
@@ -164,12 +157,7 @@
   [n]
   (letfn [(next
             [k]
-            (if (> k n)
-              nil
-              (let [f (fib k)]
-                (if (even? f)
-                  (cons f (next (inc k)))
-                  (next (inc k))))))]
+            (when-not (> k n) (let [f (fib k)] (if (even? f) (cons f (next (inc k))) (next (inc k))))))]
     (next 0)))
 
 (defn my-filter
@@ -189,9 +177,7 @@
 
 (defn enumerate-interval
   [low high]
-  (if (> low high)
-    nil
-    (cons low (enumerate-interval (+ low 1) high))))
+  (when-not (> low high) (cons low (enumerate-interval (inc low) high))))
 
 (defn enumerate-tree
   [tree]
@@ -245,7 +231,7 @@
   (accumulate append nil
               (map (fn [i]
                      (map (fn [j] (list i j))
-                          (enumerate-interval 1 (- i 1))))
+                          (enumerate-interval 1 (dec i))))
                    (enumerate-interval 1 6))))              ; (1 2 3 4 5 6)
 ; ((2 1) (3 1) (3 2) (4 1) (4 2) (4 3) (5 1) (5 2) (5 3) (5 4) (6 1) (6 2) (6 3) (6 4) (6 5))
 
@@ -269,12 +255,12 @@
        (filter prime-sum? (flatmap
                             (fn [i]
                               (map (fn [j] (list i j))
-                                   (enumerate-interval 1 (- i 1))))
+                                   (enumerate-interval 1 (dec i))))
                             (enumerate-interval 1 n)))))
 
 (defn my-remove
   [item sequence]
-  (filter (fn [x] (not (= x item))) sequence))
+  (filter (fn [x] (not= x item)) sequence))
 
 (defn permutations
   [s]
@@ -388,7 +374,7 @@
 
 (defn corner-split
   [painter n]
-  (if (= n 0)
+  (if (zero? n)
     painter
     (let [up           (corner-split painter (dec n))
           right        (corner-split painter (dec n))

src/sicp/chapter_2/part_2/ex_2_19.clj

@@ -62,8 +62,8 @@
 
 (defn cc
   [amount coin-values]
-  (cond (= amount 0) 1
-        (or (< amount 0)
+  (cond (zero? amount) 1
+        (or (neg? amount)
             (no-more? coin-values)) 0
         :else (+ (cc amount (except-first-denomination coin-values))
                  (cc (- amount (first-denomination coin-values)) coin-values))))

src/sicp/chapter_2/part_2/ex_2_21.clj

@@ -22,8 +22,7 @@
 
 (defn square-list-1
   [items]
-  (if (m/list-empty? items)
-    nil
+  (when-not (m/list-empty? items)
     (cons (* (m/car items) (m/car items))
           (square-list-1 (m/cdr items)))))
 

src/sicp/chapter_2/part_2/ex_2_23.clj

@@ -30,4 +30,4 @@
       (for-each proc (m/cdr items)))))
 
 (comment
-  (for-each #(println %) (list 57 321 88)))
+  (for-each println (list 57 321 88)))

src/sicp/chapter_2/part_2/ex_2_36.clj

@@ -24,7 +24,6 @@
 
 (defn accumulate-n
   [op init seqs]
-  (if (nil? (m/car seqs))
-    nil
+  (when-not (nil? (m/car seqs))
     (cons (b22/accumulate op init (map m/car seqs))
           (accumulate-n op init (map m/cdr seqs)))))

src/sicp/chapter_2/part_2/ex_2_40.clj

@@ -14,7 +14,7 @@
   (b22/flatmap
     (fn [i]
       (map (fn [j] (list i j))
-           (b22/enumerate-interval 1 (- i 1))))
+           (b22/enumerate-interval 1 (dec i))))
     (b22/enumerate-interval 1 n)))
 
 (defn prime-sum-pairs

src/sicp/chapter_2/part_2/ex_2_42.clj

@@ -99,12 +99,12 @@
   [board-size]
   (letfn [(queen-cols
             [k]
-            (if (= 0 k)
+            (if (zero? k)
               (list nil)                                    ; It's `empty-board`
               (filter (fn [positions] (safe? k positions))
                       (mapcat (fn [rest-of-queens]
                                 (map (fn [new-row]
                                        (adjoin-position new-row k rest-of-queens))
                                      (b22/enumerate-interval 1 board-size)))
-                              (queen-cols (- k 1))))))]
+                              (queen-cols (dec k))))))]
     (queen-cols board-size)))

src/sicp/chapter_2/part_2/ex_2_43.clj

@@ -27,28 +27,28 @@
   [board-size]
   (letfn [(queen-cols
             [k]
-            (if (= 0 k)
+            (if (zero? k)
               (list nil)
               (filter (fn [positions] (ex-2-42/safe? k positions))
                       (mapcat (fn [rest-of-queens]
                                 (map (fn [new-row]
                                        (ex-2-42/adjoin-position new-row k rest-of-queens))
                                      (b22/enumerate-interval 1 board-size)))
-                              (queen-cols (- k 1))))))]
+                              (queen-cols (dec k))))))]
     (queen-cols board-size)))
 
 (defn queens-2-43
   [board-size]
   (letfn [(queen-cols
             [k]
-            (if (= 0 k)
+            (if (zero? k)
               (list nil)
               (filter (fn [positions] (ex-2-42/safe? k positions))
                       (mapcat (fn [new-row]
                                 ; diff 1
                                 (map (fn [rest-of-queens]
                                        ; diff 1
                                        (ex-2-42/adjoin-position new-row k rest-of-queens))
-                                     (queen-cols (- k 1)))) ; diff 2
+                                     (queen-cols (dec k)))) ; diff 2
                               (b22/enumerate-interval 1 board-size)))))] ; diff 2
     (queen-cols board-size)))

src/sicp/chapter_2/part_2/ex_2_44.clj

@@ -10,7 +10,7 @@
 (defn up-split
   [painter n]
   ; Just a potential solution...
-  (if (= n 0)
+  (if (zero? n)
     painter
     (let [down (up-split painter (dec n))
           up   (up-split painter (dec n))]

src/sicp/chapter_2/part_2/ex_2_45.clj

@@ -15,7 +15,7 @@
 (defn split
   [primary secondary]
   (fn [painter n]
-    (if (= n 0)
+    (if (zero? n)
       painter
       (let [smaller         ((split primary secondary) painter (dec n))
             primary-split   (primary painter smaller)

src/sicp/chapter_2/part_3/book_2_3.clj

@@ -49,8 +49,8 @@
 (defn make-sum
   [a1 a2]
   (cond
-    (= a1 0) a2
-    (= a2 0) a1
+    (zero? a1) a2
+    (zero? a2) a1
     (and (number? a1) (number? a2)) (+ a1 a2)
     :else (list '+ a1 a2)))
 
@@ -242,7 +242,7 @@
 (defn choose-branch
   [bit branch]
   (cond
-    (= bit 0) (left-branch-h branch)
+    (zero? bit) (left-branch-h branch)
     (= bit 1) (right-branch-h branch)
     :else (throw (Exception. (str "bad bit: CHOOSE-BRANCH " bit)))))
 

src/sicp/chapter_2/part_3/ex_2_56.clj

@@ -28,7 +28,7 @@
 (defn make-exponentiation
   [base exponent]
   (cond
-    (= exponent 0) 1.0
+    (zero? exponent) 1.0
     (and (= exponent 1) (number? base)) (float base)
     (and (number? base) (number? exponent)) (Math/pow base exponent)
     :else (list '** base exponent)))