[macros] Lisp 매크로를 그렇게 특별하게 만드는 것은 무엇입니까?

짧은 대답을 제공하기 위해 매크로는 공통 Lisp 또는 DSL (Domain Specific Languages)에 대한 언어 구문 확장을 정의하는 데 사용됩니다. 이러한 언어는 기존 Lisp 코드에 바로 포함됩니다. 이제 DSL은 Lisp와 유사한 구문 (예 : Peter Norvig의 Common Lisp 의 Prolog Interpreter ) 또는 완전히 다른 (예 : Clojure의 Infix Notation Math) 을 가질 수 있습니다 .

좀 더 구체적인 예는 다음과 같습니다.
파이썬에는 언어에 내장 된 목록 이해력이 있습니다. 이것은 일반적인 경우에 대한 간단한 구문을 제공합니다. 라인

divisibleByTwo = [x for x in range(10) if x % 2 == 0]

0에서 9 사이의 모든 짝수를 포함하는 목록을 생성합니다. Python 1.5 에서 그 와 같은 구문은 없었습니다. 다음과 같은 것을 사용하십시오.

divisibleByTwo = []
for x in range( 10 ):
   if x % 2 == 0:
      divisibleByTwo.append( x )

이들은 기능적으로 동일합니다. 불신의 서스펜션을 시작하고 Lisp에 매우 제한된 루프 매크로가 있다고 가정 해 봅시다. 반복을 수행하고 목록 이해에 해당하는 쉬운 방법은 없습니다.

Lisp에서 다음을 작성할 수 있습니다. 이 고안된 예제는 Lisp 코드의 좋은 예제가 아닌 Python 코드와 동일하도록 선택되었습니다.

;; the following two functions just make equivalent of Python's range function
;; you can safely ignore them unless you are running this code
(defun range-helper (x)
  (if (= x 0)
      (list x)
      (cons x (range-helper (- x 1)))))

(defun range (x)
  (reverse (range-helper (- x 1))))

;; equivalent to the python example:
;; define a variable
(defvar divisibleByTwo nil)

;; loop from 0 upto and including 9
(loop for x in (range 10)
   ;; test for divisibility by two
   if (= (mod x 2) 0)
   ;; append to the list
   do (setq divisibleByTwo (append divisibleByTwo (list x))))

더 나아 가기 전에 매크로가 무엇인지 더 잘 설명해야합니다. 코드에 의해 수행되는 변환입니다. 코드 입니다. 즉, 코드를 인수로 받아들이는 인터프리터 (또는 컴파일러)가 읽은 코드 조각은 결과를 조작하고 결과를 반환하며 그 자리에서 실행됩니다.

물론 그것은 많은 타이핑이고 프로그래머는 게으르다. 그래서리스트 이해를위한 DSL을 정의 할 수있었습니다. 실제로, 우리는 이미 하나의 매크로 (루프 매크로)를 사용하고 있습니다.

Lisp는 몇 가지 특수 구문 형식을 정의합니다. 따옴표 ( ')는 다음 토큰이 리터럴임을 나타냅니다. 준 따옴표 또는 역 따옴표 ( `)는 다음 토큰이 이스케이프 된 리터럴임을 나타냅니다. 이스케이프는 쉼표 연산자로 표시됩니다. 리터럴 '(1 2 3)은 Python과 동일 [1, 2, 3]합니다. 다른 변수에 지정하거나 대신 사용할 수 있습니다. 이전에 정의 된 변수 `(1 2 ,x)인 파이썬의 [1, 2, x]위치 와 동등한 것으로 생각할 수 있습니다 x. 이 목록 표기법은 매크로에 들어가는 마술의 일부입니다. 두 번째 부분은 코드를 지능적으로 대체하는 Lisp 판독기이지만 아래에 가장 잘 설명되어 있습니다.

따라서 lcomp(목록 이해의 줄임말) 이라는 매크로를 정의 할 수 있습니다 . 이 구문은 정확히 우리가 예에서 사용하는 파이썬처럼 될 것입니다 [x for x in range(10) if x % 2 == 0] –(lcomp x for x in (range 10) if (= (% x 2) 0))

(defmacro lcomp (expression for var in list conditional conditional-test)
  ;; create a unique variable name for the result
  (let ((result (gensym)))
    ;; the arguments are really code so we can substitute them 
    ;; store nil in the unique variable name generated above
    `(let ((,result nil))
       ;; var is a variable name
       ;; list is the list literal we are suppose to iterate over
       (loop for ,var in ,list
            ;; conditional is if or unless
            ;; conditional-test is (= (mod x 2) 0) in our examples
            ,conditional ,conditional-test
            ;; and this is the action from the earlier lisp example
            ;; result = result + [x] in python
            do (setq ,result (append ,result (list ,expression))))
           ;; return the result 
       ,result)))

이제 명령 행에서 실행할 수 있습니다 :

CL-USER> (lcomp x for x in (range 10) if (= (mod x 2) 0))
(0 2 4 6 8)

꽤 깔끔하지? 이제 거기서 멈추지 않습니다. 원한다면 메카니즘이나 붓이 있습니다. 원하는 구문을 사용할 수 있습니다. 파이썬이나 C #의 with구문 처럼 . 또는 .NET의 LINQ 구문. 결국 이것이 궁극적 인 유연성 인 사람들을 Lisp로 끌어들이는 것입니다.

답변

expr1 && expr2 && expr3 ...

and(expr1, expr2, expr3)

(defmacro && (expr1 &rest exprs)
    `(if ,expr1                     ;` Warning: I have not tested
         (&& ,@exprs)               ;   this and might be wrong!
         nil))

(&& (very-cheap-operation)
    (very-expensive-operation)
    (operation-with-serious-side-effects))

and(very_cheap_operation(),
    very_expensive_operation(),
    operation_with_serious_side_effects());

(setvar *rows* (sql select count(*)
                      from some-table
                     where column1 = "Yes"
                       and column2 like "some%string%")

define macro "using":
    using ($type $varname = $expression) $block
into:
    $type $varname;
    try {
       $varname = $expression;
       $block;
    } finally {
       $varname.Dispose();
    }