       (f '(13)) 1
       (f '(:a :b :c))) 3))
 
-
+#_
 (deftest using-if
   (are [x y] (= x y)
     (if (> 1 0)
       true
       false)
-    true
+    ___
 
     (if (> 3 2 1)
       true
       false)
-    true
+    ___
 
     (if (> 3 2 3 1)
       true
       false)
-    false
+    ___
 
     (if nil
       "nil is truthy"
       "nil is falsey"
-      ) "nil is falsey"
+      ) ___
 
     (if true
       "true is truthy"
       "true is falsey"
-      ) "true is truthy"
+      ) ___
 
     (if false
       "false is truthy"
       "false is falsey"
-      ) "false is falsey"
+      ) ___
 
     (if '(1)
       "list is truthy"
       "list is falsey"
-      ) "list is truthy"
+      ) ___
 
     (if '()
       "empty list is truthy"
       "empty list is falsey"
-      ) "empty list is truthy"
+      ) ___
 
     (if (Object.)
       "Object is truthy"
       "Object is falsey"
-      ) "Object is truthy"))
+      ) ___))
 
-
+#_
 (deftest dealing-with-lists
   (are [x y] (= x y)
   ;; Should be able to use one simple function call to get result
-       (first '(1 2 3 4))  1
-       (last '(1 2 3 4 5)) 5
-       (take 2 '(1 2 3 4)) '(1 2)))
+       (__ '(1 2 3 4))  1
+       (__ '(1 2 3 4 5)) 5
+       (__ '(1 2 3 4)) '(1 2)))
 
+#_
 (deftest operating-on-lists
   (are [x y] (= x y)
   ;; Here you should try to apply the correct function to get the expected result
-       (apply + [1 2 3 4]) 10
-       (apply - [4 3 2 1]) -2
-       (apply * [1 2 3 4]) 24
+       (apply __ [1 2 3 4]) 10
+       (apply __ [4 3 2 1]) -2
+       (apply __ [1 2 3 4]) 24
        ))
 
-
+#_
 (deftest how-to-filter-out-the-stuff-you-want
   (are [x y] (= x y)
   ;; Filter is cool. Can you write or use a cool function to get correct result?
-    (filter odd? '(1 2 3 4 5)) '(1 3 5)
-    (filter even? '(1 2 3 4 5)) '(2 4)))
+    (filter __ '(1 2 3 4 5)) '(1 3 5)
+    (filter __ '(1 2 3 4 5)) '(2 4)))
 
+#_
 (deftest use-map-to-double-all-numbers-in-a-sequence
   ;; Write a function in the let form that doubles its input
-  (let [double (fn [x] (* 2 x))]
+  (let [double __]
     (are [x y] (= x y)
       (map double '(1 2 3)) '(2 4 6)
       (map double '(5 10 15)) '(10 20 30))))
 
+#_
 (deftest define-a-function-that-checks-string-longer-than
   ;; Write a function in the let form that that checks that the input String is longer than number input.
-  (let [longer-than? (fn [str len] (> (count str) len))]
+  (let [longer-than? __]
     (are [x y] (= x y)
          (longer-than? "long string" 5) true
          (longer-than? "short" 5) false

  ;; Oh, and by the way. 'are' creates a template (using a macro),
  ;; for alle the following test form, which need to be in pairs in this case.
  (are [x y] (= x y)
    (conj [1] 2) [1 2]
    (conj [1 2] 3 4) [1 2 3 4]
    (conj '(2 1) 3 4) '(4 3 2 1)
    (conj #{2 1} 3 4) #{1 2 3 4}))


(deftest how-to-count-stuff
  (are [x y] (= x y)
       5 (count '(1 2 3 4 5))
       4 (count [1 2 3 4])
       10 (count (range 10))
       4 (count {:a 1, :b 2, :c 3, :d 4})
       8 (count "En banan")))


(deftest how-to-find-length-of-something
  ;; First class functions are so cool. Put in the right function in let
  ;; and all assertions should be correct.
  (let [f count]
    (are [x y] (= x y)
      (f '(1 2 3 3 1)) 5
      (f "Hello World") 11

(defn __ [& args] false)
(def ___ '())

#_
(deftest very-basic-types
  (is (= 1 1))
  ;; Lots of things are truthy, which is the simplest?
  (is (true? ___))
  ;; Now what is the concatenation of those Characters
  (is (= (str \a \b \c) ___))
  ;; Use vector literal
  (is (= '(1 2 3) ___))
  ;; Use list literal
  (is (= [1 2 3] ___))
  ;; Use list function
  (is (= [1 2 3] ___))
  ;; Use vector function
  (is (= [1 2 3] ___)))

#_
(deftest use-conjoin
  ;; conjoin is a special function that works with most datastructures.
  ;; It nows where the right place is to append an element.
