Common Lisp vs Racket(gist.github.com)

    (define-syntax (nest stx)
      (syntax-case stx ()
        ((nest outer ... inner)
         (foldr (lambda (o i)
                  (with-syntax (((outer ...) o)
                                 (inner i))
                    #'(outer ... inner)))
                #'inner (syntax->list #'(outer ...))))))

    #lang racket
    
    #;(defmacro nest (&rest r)
        (reduce (lambda (o i) `(,@o ,i)) r :from-end t))
    
    (begin-for-syntax
      (require racket/match)
      (define (reduce f xs)
        (match xs
          [(list x0 x1) (f x0 x1)]
          [(cons a d)   (f a (reduce f d))])))
    
    (define-syntax (nest r)  
      (reduce (λ (o i) #`(#,@o #,i))
              (cdr (syntax->list r))))
    
    (nest
     (list 'foo)
     (list 'bar)
     (list 'baz)
     'qux)

    with(s = fopen("/foo/bar", ...)) {
        ...;
        ...;
        println(readln(s));
        ...;
        ...;
     }

    (defgeneric destroy (x)
      (:documentation "A destructor for use with the WITH feature".))

    (defmacro with ((var = val) &body body)
      "Python-style RAII macro. VAR will be
       bound to the value of VAL, and upon
       exiting scope, will be destroyed with
       DESTROY."
      (assert (eq = ':=))
      (let ((orig (gensym)))
        `(let* ((,orig ,val)
                (,var ,orig))
           (unwind-protect
               (progn ,@body)
             (destroy ,orig))))

    (defmethod destroy ((s stream))
      (close stream))

    (with (s := (open "/foo/bar" ...))
      ...
      ...
      (write-line (read-line s))
      ...
      ...)

    (defun while (c body)
      (when (funcall c)
        (funcall body)
        (while c body)))