diff --git a/src/recursion.clj b/src/recursion.clj
index 95d77aa..5e91f7e 100644
--- a/src/recursion.clj
+++ b/src/recursion.clj
@@ -1,52 +1,104 @@
 (ns recursion)
 
 (defn product [coll]
-  :-)
+  (if (empty? coll)
+    1
+    (* (first coll)
+       (product (rest coll)))))
 
 (defn singleton? [coll]
-  :-)
+  (and (not(empty? coll)) (empty? (rest coll))))
 
 (defn my-last [coll]
-  :-)
+  (if (singleton? coll)
+    (apply int coll)
+    (my-last (rest coll))))
 
 (defn max-element [a-seq]
-  :-)
+  (let [fst (first a-seq)
+        rst (rest a-seq)]
+    (if (empty? rst)
+        fst
+        (max fst (max-element rst)))))
 
 (defn seq-max [seq-1 seq-2]
-  [:-])
+  (cond
+    (<= (count seq-1) (count seq-2)) seq-2
+    :else seq-1
+    ))
 
 (defn longest-sequence [a-seq]
-  [:-])
+  (let [fst (first a-seq)
+        rst (rest a-seq)]
+    (if (empty? rst)
+        fst
+        (seq-max fst (longest-sequence rst)))))
 
 (defn my-filter [pred? a-seq]
-  [:-])
+    (lazy-seq
+      (when (seq a-seq)
+        (if (pred? (first a-seq))
+          (cons (first a-seq) (my-filter pred? (rest a-seq)))
+          (my-filter pred? (rest a-seq))))))
 
 (defn sequence-contains? [elem a-seq]
-  :-)
+  (cond
+    (empty? a-seq)
+      false
+    (not(= elem (first a-seq)))
+      (sequence-contains? elem (rest a-seq))
+    :else
+      true))
 
 (defn my-take-while [pred? a-seq]
-  [:-])
+    (lazy-seq
+      (when (seq a-seq)
+        (if (pred? (first a-seq))
+          (cons (first a-seq) (my-take-while pred? (rest a-seq)))
+          ))))
 
 (defn my-drop-while [pred? a-seq]
-  [:-])
+    (lazy-seq
+      (when (seq a-seq)
+        (if (pred? (first a-seq))
+          (my-drop-while pred? (rest a-seq))
+          a-seq
+
+          ))))
 
 (defn seq= [a-seq b-seq]
-  :-)
+  (cond
+    (not(= (count (rest a-seq)) (count (rest b-seq)))) false
+    (and (empty? a-seq) (empty? b-seq)) true
+    (= (first a-seq)( first b-seq)) (seq= (rest a-seq) (rest b-seq))
+    :else false))
 
 (defn my-map [f seq-1 seq-2]
-  [:-])
+  (if (or (empty? seq-1) (empty? seq-2))
+    '()
+    (cons (f (first seq-1) (first seq-2))
+          (my-map f (rest seq-1) (rest seq-2)))))
 
 (defn power [n k]
-  :-)
+  (if (zero? k)
+    1
+    (* n (power n (dec k)))))
 
 (defn fib [n]
-  :-)
+  (if (< n 2)
+    n
+    (+ (fib (- n 1))
+       (fib (- n 2)))))
 
 (defn my-repeat [how-many-times what-to-repeat]
-  [:-])
+  (if (zero? how-many-times)
+    what-to-repeat
+    (cons (my-repeat (dec how-many-times) what-to-repeat) what-to-repeat)))
 
 (defn my-range [up-to]
-  [:-])
+  (if (zero? up-to)
+    ()
+    (cons (my-range (dec up-to)) (up-to)))
 
 (defn tails [a-seq]
   [:-])