;;use kezban.core
(use 'kezban.core)

user=> (when-let* [a 1 b 2 c 3]
                  (println "I <3 Clojure")
                  a)
=> "I <3 Clojure"
=> 1

;;returns nil when one binding is nil or false
user=> (when-let* [a 1 b nil c 3]
                  (println "Please print me!")
                  a)
=> nil                              

user=> (if-let* [a 1 b 2 c (+ a b)]
                c)
=> 3

;;returns then part when one binding is nil or false
user=> (if-let* [a 1 b nil c 3]
                "Nope not here"
                "Here I Am!")
=> "Here I Am!"         

(cond-as-> 1 n
           true (+ n 1)
           false (+ n 2)
           true  (+  5 n))
=> 7

;; Alternative to ->, ->> and (comp) with one arg
;; Applying Left-To-Right
;; First Argument has to be a value(input)!

;; comp equivalent: ((comp #(+ 1 %) #(+ % 1) inc) 5)
;; standard equivalent (+ 1 (+ (inc 5) 1))

user=> (->>> 5 inc #(+ % 1) #(+ 1 %)) ;;5 is the input
=> 8


;; comp equivalent: ((comp inc second reverse) '("a" 2 8 "b"))
;; standard equivalent (inc (second (reverse '("a" 2 8 "b"))))

user=> (->>> '("a" 2 8 "b") reverse second inc) ;;'("a" 2 8 "b") is the input
=> 9

(def coll [1 2 3 4 5])

user=> (nth-safe coll 0)
=> 1

user=> (nth-safe coll 12)
=> nil

user=> (nth-safe coll 12 "not-found-value")
=> "not-found-value"

(nnth [1 [2 3 [4 5]]] 1 2 1)
=> 5

(def- my-coll [1 2 3])
=> #'kezban.core/my-coll

(:private (meta #'kezban.core/my-coll))
=> true

(xor false true nil)
=> true

(xor false nil)
=> nil

(pprint-macro (when-let [a 1]
                (println a)))
(let*
 [temp__4657__auto__ 1]
 (if temp__4657__auto__ (do (let* [a temp__4657__auto__] (println a)))))
=> nil

(quoted? '(+ 1  2))
=> true

(quoted? (+ 1  2))
=> false

(array? (int-array 1))
=> true

(array? :int (int-array 1))
=> true

(lazy? (map inc [1 2 3]))
=> true

(filter (any-pred even? odd?) [2 4 5 7])
=> (2 4 5 7)

(try-> 5 inc dec str inc) ;;also thread last version: try->>
=> nil

(def data [{:v 12, :a 10} {:v 21, :a 113} {:v 1, :a 2} {:v 12, :a 223} {:v 100, :a 23} {:v 1, :a 113}])

(sort #(multi-comp [:a :v] > %1 %2) data)
;or
(sort #(multi-comp [:a :v] %2 %1) data)
=> ({:v 12, :a 223} {:v 21, :a 113} {:v 1, :a 113} {:v 100, :a 23} {:v 12, :a 10} {:v 1, :a 2})

(with-out 
 (println "Normal out") 
 (.println (System/err) "Error occurred!"))
=> {:err "Error occurred!\n", :out "Normal out\n"}

(letm [a 1
       b (+ a 1)])
=> {:a 1, :b 2}

(in? 3 [1 2 3 4])
=> true

(take-while-and-n-more even? 2 [2 4 6 7 9 13 15])
=> (2 4 6 7 9)

(dissoc-in {:a {:b {:c 1 :d 2}}} [:a :b :d])
=> {:a {:b {:c 1}}}

(with-timeout 100
              (Thread/sleep 1500))
=> CompilerException java.util.concurrent.TimeoutException

(with-timeout 1000
              (Thread/sleep 500)
              5)
=> 5

(url->file "http://file.url" (io/file "your file path to get content"))
=> returns your file instance

(cond-let [a 5
           b (+ a 1)]

          (even? a)
          (println "a is odd")

          (even? b)
          (println "b is even"))
b is even
=> nil

(keywordize "hey Whats Up?")
=> :hey-whats-up?

(source-clj-file 'clojure.string)
=> returns clojure.string's namespace source code in string

;;unlike time, time* allows you to provide more than one form
(time* 
  (Thread/sleep 2500)
  12)
  
=> {:duration 2505.328818, :result 12}

(process-lazy-seq (fn [i]
                    (println (inc i))) 10000 (range))
                    
;; we can process 10000 data at time and not getting OutOfMemory Exception

;; binding will happen when *compile-files* set to false
(def db-conn (when-no-aot (create-db-connection!)))

(defay current-time  (println "Hi!") (System/currentTimeMillis))
;; Hi!
;;=> 1587327846466

@current-time

;;=> 1587327846466

;; Expands to this:
(def current-time (delay (println "Hi!")
                         (System/currentTimeMillis)))

(when-not *compile-files* @current-time)

(defn my-fn
  [a]
  (let [b 2]
    (locals)))

(my-fn 1)
;;=> {a 1, b 2}

(prog1 (+ 1 2)
  (println "Result: " <>))

;;Result:  3
;;=> 3

(defm my-add [x y]
  (println "Result: " (+ x y))
  (+ x y))

(my-add 1 2)
;;Result:  3
;;=> 3

(my-add 1 2)
;;=> 3

Memoized function, expands to this:

(def my-add
  (memoize
    (fn [x y]
      (println "Result: " (+ x y))
      (+ x y))))