#!r6rs

(import (rnrs))

(define-syntax capture-a
  (lambda (stx)
    (syntax-case stx ()
      ((capture-a) (datum->syntax #'capture-a 'a)))))

(define-syntax capture-not
  (lambda (stx)
    (syntax-case stx ()
      ((capture-not condition)
       #`(#,(datum->syntax #'capture-not 'not) condition)))))

(define-syntax hygienic-not
  (syntax-rules ()
    ((_ condition) (not condition))))

(define-syntax custom-print
  (syntax-rules ()
    ((_ value) (let ((a 42)) (print value)))))

(define-syntax swap!
  (syntax-rules ()
    ((_ x y) (let ((value x))
               (set! x y)
               (set! y value)))))

(define-syntax capture-swap!
  (lambda (stx)
    (syntax-case stx ()
      ((capture-swap! x y)
       #`(let-syntax ((set! (syntax-rules ()
                              ((_ name val) (#,(datum->syntax #'capture-swap! 'set!) name val)))))
           (let ((value x))
             (set! x y)
             (set! y value)))))))

(define print
  (lambda (value)
    (display value)
    (newline)))

(print (capture-not #f))
(print (let ((not (lambda (x) x)))
         (capture-not #f)))

(print (hygienic-not #f))
(print (let ((not (lambda (x) x)))
         (hygienic-not #f)))

(let ((b 23))
  (custom-print b))
(let ((a 23))
  (custom-print a))

(define a 42)
(define b 23)
(swap! a b)
(capture-swap! a b)
(let ((set! +))
  (print (capture-swap! a b)))
(print a)
(print b)