Clojure macro

(defmacro when
  "Evaluates test. If logical true, evaluates body in an implicit do."
  {:added "1.0"}
  [test & body]
  (list 'if test (cons 'do body)))

(when (= 3 (+ 1 2))
  (println "a")
  (println "b"))

(macroexpand-1 '(when (= 3 (+ 1 2))
                      (println "a")
                      (println "b")))

=> (if (= 3 (+ 1 2))
       (do (println "a")
           (println "b")))

(defmacro when-not
  "Evaluates test. If logical false, evaluates body in an implicit do."
  {:added "1.0"}
  [test & body]
    (list 'if test nil (cons 'do body)))

(macroexpand-1 '(when-not (= 3 (+ 1 2))
                          (println "a")
                          (println "b")))
=> (if (= 3 (+ 1 2))
       nil    ; true 인 경우 nil 리턴
       (do (println "a")
           (println "b")))

(defmacro cond
  "Takes a set of test/expr pairs. It evaluates each test one at a
  time.  If a test returns logical true, cond evaluates and returns
  the value of the corresponding expr and doesn't evaluate any of the
  other tests or exprs. (cond) returns nil."
  {:added "1.0"}
  [& clauses]
    (when clauses
      ;; 첫 번째 clause가 참이라면,
      (list 'if (first clauses)
            ;; 첫 번째 clause에 이어지는 이후 clause들이 존재하는지 확인한다.
            (if (next clauses)
                ;; 이후 clause들이 있다면 첫 번째 clause의 짝인 두 번째 clause를 평가하고 리턴한다.
                (second clauses)

                ;; 평가는 참이었는데 실행 구문이 없다!
                ;; cond를 문법에 맞지 않게 사용한 것이다. 예외를 던진다.
                (throw (IllegalArgumentException.
                         "cond requires an even number of forms")))

            ;; 첫 번째 caluse가 참이 아니라면, 세 번째 clause부터 재귀 cond.
            (cons 'clojure.core/cond (next (next clauses))))))

(macroexpand-1 '(cond (= 2 3)           ; 첫 번째 clause
                      (println "2 = 3") ; 두 번째 clause

                      (= 3 3)           ; 세 번째 clause
                      (println "3 = 3") ; 네 번째 clause

                      :else             ; 다섯 번째 clause
                      (println "end"))) ; 여섯 번째 clause

=> (if (= 2 3)
       (println "2 = 3");   ; 첫번째, 두번째 clause를 처리, 나머지 clause들은 재귀로 처리
       (clojure.core/cond (= 3 3) (println "3 = 3")
                          (= 4 5) (println "4 = 5")
                          :else   (println "end")))

(defmacro lazy-seq
  "Takes a body of expressions that returns an ISeq or nil, and yields
  a Seqable object that will invoke the body only the first time seq
  is called, and will cache the result and return it on all subsequent
  seq calls. See also - realized?"
  {:added "1.0"}
  [& body]
  (list 'new 'clojure.lang.LazySeq (list* '^{:once true} fn* [] body)))

(defn fibonacci
  ([]
   (fibonacci 1 1))
  ([a b]
   (lazy-seq (cons a
                   (fibonacci b (+ a b))))))

(take 15 (fibonacci))
; (1 1 2 3 5 8 13 21 34 55 89 144 233 377 610)

(def fibonacci
  (fn*
    ([]
     (fibonacci 1 1))
    ([a b]
     (new clojure.lang.LazySeq #(cons a (fibonacci b (+ a b)))))))

(defmacro delay
  "Takes a body of expressions and yields a Delay object that will
  invoke the body only the first time it is forced (with force or deref/@), and
  will cache the result and return it on all subsequent force
  calls. See also - realized?"
  {:added "1.0"}
  [& body]
    (list 'new 'clojure.lang.Delay (list* `^{:once true} fn* [] body)))

(defmacro lazy-seq
  [& body]
  (list 'new 'clojure.lang.LazySeq (list* '^{:once true} fn* [] body)))

(defmacro if-not
  "Evaluates test. If logical false, evaluates and returns then expr, 
  otherwise else expr, if supplied, else nil."
  {:added "1.0"}
  ([test then] `(if-not ~test ~then nil))
  ([test then else]
   `(if (not ~test) ~then ~else)))

(defmacro and
  "Evaluates exprs one at a time, from left to right. If a form
  returns logical false (nil or false), and returns that value and
  doesn't evaluate any of the other expressions, otherwise it returns
  the value of the last expr. (and) returns true."
  {:added "1.0"}
  ([] true)
  ([x] x)
  ([x & next]
   `(let [and# ~x]
      (if and# (and ~@next) and#))))

;; 거짓이 하나라도 포함되어 있는 경우
;; macro 정의대로 가장 먼저 거짓으로 평가되는 값을 리턴
(and nil 3)     ; nil
(and false 3)   ; false
(and 1 2 3 false 4) ; false

;; 모두 참인 경우
;; macro 정의대로 순서대로 평가해서 가장 마지막에 참으로 평가한 값을 리턴
(and 1 2 3 4)       ; 4
(and true #{} [] 7) ; 7

(macroexpand-1 '(and 11 22 33 44 55 66 77 false))
=>
;; let 에서 gensym에 11 을 할당한다
(clojure.core/let [and__5531__auto__ 11]
 (if and__5531__auto__
     ;; 첫 번째 조건이 참이면, 나머지 조건들에 대해서 재귀한다
     (clojure.core/and 22 33 44 55 66 77 false)
     ;; 첫 번째 조건이 거짓이면, 거짓으로 평가한 값을 리턴한다
     and__5531__auto__))

(defmacro or
  "Evaluates exprs one at a time, from left to right. If a form
  returns a logical true value, or returns that value and doesn't
  evaluate any of the other expressions, otherwise it returns the
  value of the last expression. (or) returns nil."
  {:added "1.0"}
  ([] nil)
  ([x] x)
  ([x & next]
      `(let [or# ~x]
         (if or# or# (or ~@next)))))

`(let [and# ~x]
      ;; and는 첫 번째 인자가 참이어도 나머지를 모두 검사해야 한다
      (if and#
        (and ~@next)
        and#))

`(let [or# ~x]
      ;; or는 첫 번째 인자가 참이라면 검사가 끝난다
      (if or#
        or#
        (or ~@next)))

(defmacro locking
  "Executes exprs in an implicit do, while holding the monitor of x.
  Will release the monitor of x in all circumstances."
  {:added "1.0"}
  [x & body]
  `(let [lockee# ~x]
     (try
       (let [locklocal# lockee#]
         (monitor-enter locklocal#)
         (try
           ~@body
           (finally
            (monitor-exit locklocal#)))))))

(doc monitor-enter)
-------------------------
monitor-enter
  (monitor-enter x)
Special Form
  Synchronization primitive that should be avoided
  in user code. Use the 'locking' macro.

  Please see http://clojure.org/special_forms#monitor-enter

(defmacro ..
  "form => fieldName-symbol or (instanceMethodName-symbol args*)

  Expands into a member access (.) of the first member on the first
  argument, followed by the next member on the result, etc. For
  instance:

  (.. System (getProperties) (get \"os.name\"))

  expands to:

  (. (. System (getProperties)) (get \"os.name\"))

  but is easier to write, read, and understand."
  {:added "1.0"}
  ;; form이 1개인 경우에는 . 으로 Java 코드를 호출한다.
  ([x form] `(. ~x ~form))
  ;; form 이후 여러 인자가 있다면 ~@more 를 사용해 재귀한다.
  ([x form & more] `(.. (. ~x ~form) ~@more)))

(.. "fooBAR" (toLowerCase) (substring 3))
=> "bar"

(defmacro ..
  ;; form이 1개인 경우에는 . 으로 Java 코드를 호출한다.
  ([x form] `(. ~x ~form)) ; Java 로 따지면 객체 x의 메소드 호출 form을 실행하는 것.

  ;; form 이후 인자가 있다면 ~@more 를 사용해 재귀한다.
  ([x form & more] `(.. (. ~x ~form) ~@more)))

(defmacro ->
  "Threads the expr through the forms. Inserts x as the
  second item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  second item in second form, etc."
  {:added "1.0"}
  [x & forms]
  (loop [x x, forms forms]
    (if forms
      ;; forms 가 있다면.

      (let [form (first forms)  ; 실행할 form
            threaded (if (seq? form)
                        ;; form이 (A B C) 같은 시퀀스라면, (A x B C) 처럼 x를 넣어 실행한다
                        ;; 그리고 메타데이터가 유실되지 않도록 붙여준다.
                       (with-meta `(~(first form) ~x ~@(next form)) (meta form))

                       ;; form 이 시퀀스가 아니라면 그냥 함수만 있는 것이다.
                       ;; (form x)로 실행한다
                       (list form x))]
        ;; 나머지 form들이 있으므로 다음 loop를 진행한다
        (recur threaded (next forms)))

      ;; forms 가 없다면, 넘겨받은 x 를 리턴한다
      x)))

(defmacro ->>
  "Threads the expr through the forms. Inserts x as the
  last item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  last item in second form, etc."
  {:added "1.1"}
  [x & forms]
  (loop [x x, forms forms]
    (if forms
      (let [form (first forms)
            threaded (if (seq? form)
              ;;                                         ↓
              (with-meta `(~(first form) ~@(next form)  ~x) (meta form))
              (list form x))]
        (recur threaded (next forms)))
      x)))

(defmacro ^{:private true} assert-args
  [& pairs]
  `(do
     ;; (first pairs)가 참이 아니라면 예외를 던진다.
     (when-not ~(first pairs)
         (throw (IllegalArgumentException.
                  (str (first ~'&form) " requires " ~(second pairs) " in " ~'*ns* ":" (:line (meta ~'&form))))))
     ;; 예외를 안 던졌다면 다음 값을 체크하기 위해 재귀한다.
     ~(let [more (nnext pairs)]
        (when more
          (list* `assert-args more)))))

(defmacro time
  "Evaluates expr and prints the time it took.  Returns the value of
 expr."
  {:added "1.0"}
  [expr]
  `(let [start# (. System (nanoTime))  ; 시작 시간을 보관해 둔 다음,
         ret# ~expr]                   ; 표현식을 평가하고,
     ;; 소요 시간을 출력한다
     (prn (str "Elapsed time: " (/ (double (- (. System (nanoTime)) start#)) 1000000.0) " msecs"))
     ;; 그리고 표현식 평가 결과를 리턴한다
     ret#))

(defmacro defstruct
  "Same as (def name (create-struct keys...))"
  {:added "1.0"
   :static true}
  [name & keys]
  `(def ~name (create-struct ~@keys)))

(defmacro let
  "binding => binding-form init-expr
  binding-form => name, or destructuring-form
  destructuring-form => map-destructure-form, or seq-destructure-form

  Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein.

  See https://clojure.org/reference/special_forms#binding-forms for
  more information about destructuring."
  {:added "1.0", :special-form true, :forms '[(let [bindings*] exprs*)]}
  [bindings & body]
  ;; 입력 assert
  (assert-args
     ;; 바인딩이 vector 타입이어야 한다
     (vector? bindings) "a vector for its binding"
     ;; 바인딩 vector의 원소가 짝수개여야 한다
     (even? (count bindings)) "an even number of forms in binding vector")

  ;; 바인딩을 구조분해하고, let*의 첫 번째 인자로. body 리스트는 그 이후 인자로.
  `(let* ~(destructure bindings) ~@body))

;redefine fn with destructuring and pre/post conditions
(defmacro fn
  "params => positional-params*, or positional-params* & rest-param
  positional-param => binding-form
  rest-param => binding-form
  binding-form => name, or destructuring-form

  Defines a function.

  See https://clojure.org/reference/special_forms#fn for more information"
  {:added "1.0", :special-form true,
   :forms '[(fn name? [params* ] exprs*) (fn name? ([params* ] exprs*)+)]}
  ;; sigs 는 함수 시그니처
  [& sigs]
    ;; (fn name [params* ] exprs*) 처럼 사용했다면 name 이 있다.
    ;; (fn [params* ] exprs*) 처럼 사용했다면 name 이 없다.
    (let [name (if (symbol? (first sigs)) (first sigs) nil)
          sigs (if name (next sigs) sigs)
          sigs (if (vector? (first sigs))  ; 첫번째가 vector이면 인자 목록.
                 (list sigs) 
                 (if (seq? (first sigs))
                   sigs
                   ;; Assume single arity syntax
                   (throw (IllegalArgumentException. 
                            (if (seq sigs)
                              (str "Parameter declaration " 
                                   (first sigs)
                                   " should be a vector")
                              (str "Parameter declaration missing"))))))
          psig (fn* [sig]
                 ;; Ensure correct type before destructuring sig
                 (when (not (seq? sig))
                   (throw (IllegalArgumentException.
                            (str "Invalid signature " sig
                                 " should be a list"))))
                 (let [[params & body] sig
                       _ (when (not (vector? params))
                           (throw (IllegalArgumentException. 
                                    (if (seq? (first sigs))
                                      (str "Parameter declaration " params
                                           " should be a vector")
                                      (str "Invalid signature " sig
                                           " should be a list")))))
                       conds (when (and (next body) (map? (first body))) 
                                           (first body))
                       body (if conds (next body) body)
                       conds (or conds (meta params))
                       pre (:pre conds)
                       post (:post conds)                       
                       body (if post
                              `((let [~'% ~(if (< 1 (count body)) 
                                            `(do ~@body) 
                                            (first body))]
                                 ~@(map (fn* [c] `(assert ~c)) post)
                                 ~'%))
                              body)
                       body (if pre
                              (concat (map (fn* [c] `(assert ~c)) pre) 
                                      body)
                              body)]
                   (maybe-destructured params body)))
          new-sigs (map psig sigs)]
      (with-meta
        (if name
          (list* 'fn* name new-sigs)
          (cons 'fn* new-sigs))
        (meta &form))))

(defmacro loop
  "Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein. Acts as a recur target."
  {:added "1.0", :special-form true, :forms '[(loop [bindings*] exprs*)]}
  [bindings & body]
    (assert-args
      (vector? bindings) "a vector for its binding"
      (even? (count bindings)) "an even number of forms in binding vector")
    (let [db (destructure bindings)]
      (if (= db bindings)
        `(loop* ~bindings ~@body)
        (let [vs (take-nth 2 (drop 1 bindings))
              bs (take-nth 2 bindings)
              gs (map (fn [b] (if (symbol? b) b (gensym))) bs)
              bfs (reduce1 (fn [ret [b v g]]
                            (if (symbol? b)
                              (conj ret g v)
                              (conj ret g v b g)))
                          [] (map vector bs vs gs))]
          `(let ~bfs
             (loop* ~(vec (interleave gs gs))
               (let ~(vec (interleave bs gs))
                 ~@body)))))))

(defmacro comment
  "Ignores body, yields nil"
  {:added "1.0"}
  [& body])  ;; 아무 것도 안한다.