 (get-n-after-decimal-point 2.10) ;; => 10
 (get-n-after-decimal-point 2.01) ;; => 1
 
-(defn digit-parser [x & [power]]
+
+(defn single-digit-parser [x & [power]]
   (let [p (or power 10)]
   (rem x (or power 10))))
 
-(digit-parser 12)
+(single-digit-parser 12)
+
+(defn super-n-formater [n] ;; naming is hard ? :?
+  (apply str (conj [] (tens (count-tens n)) "-" (zero-to-nineteen (single-digit-parser n)))))
 
 (defn amount [n]
 

         answer (if (not (number? n)) :not-a-number
                 (if (rational? n)
                   ((fn [r] ;; rational
                      (
                        [tens-fiter (and (>= r 20) (<= r 99))
                         hundreds-filter (and (>= r 100) (<= r 999))])
                        (cond
                         (<= r 19) (zero-to-nineteen r)
                         (and (zero? (mod n 10)) 'tens-fiter)  (tens (count-tens n))
                         (and (zero? (mod n 100)) 'hundreds-filter) (tens (count-tens n))
                         ;;'(tens-fiter) "tes"
                        )) n)
                    ((fn [i] ;; irrational
                       :irrational

(def tens     {20 "twenty", 30 "thirty",  40 "fourty", 50 "fifty",
               60 "sixty" , 70 "seventy", 80 "eighty", 90 "ninety"})


(defn count-tens [n]
  (* (int (/ n 10)) 10))

(defn count-hundreds [n]
  (* (int (/ n 100))) 100)

(defn get-n-after-decimal-point [n]

  " Get .00 digits,
    up to 2 decimal places? :("

  (int ;; make it a whole number
   (*
     (read-string ;; make it a number again
       (format "0%s"
               (first (rest (re-find #"\d+(\.\d{1,2})?" (str n)))))) 100)))
