Управляющие конструкции императивных языков

;;(use-syntax (ice-9 syncase))

(define-syntax when
  (syntax-rules ()
    ((when cond? expr ...)
     (if cond? (list expr ...)))))

(define-syntax unless
  (syntax-rules ()
    ((unless cond? expr ...)
     (if (not cond?) (list expr ...)))))

(define-syntax for
  (syntax-rules (in)
    ((for x in xs expr ...)
     (letrec ((iter (lambda (l)
                      (if (not (null? l))
                          (begin (let ((x (car l)))
                                 (list expr ...))
                                 (iter (cdr l)))))))
           (iter (car (list xs)))))
   ((for xs as x expr ...)
     (letrec ((iter (lambda (l)
                      (if (not (null? l))
                          (begin
                             (let ((x (car l)))
                               (list expr ...))
                             (iter (cdr l)))))))
           (iter (car (list xs)))) )))

(define-syntax for
  (syntax-rules (in)
    ((for x in xs expr ...)
     (letrec ((iter (lambda (l)
                      (if (not (null? l))
                          (begin
                             (let ((x (car l)))
                               (list expr ...))
                             (iter (cdr l)))))))
           (iter (car (list xs)))) )
   ((for xs as x expr ...)
     (letrec ((iter (lambda (l)
                      (if (not (null? l))
                          (begin
                             (let ((x (car l)))
                               (list expr ...))
                             (iter (cdr l)))))))
           (iter (car (list xs)))) )))

(define-syntax for
  (syntax-rules (in)
    ((for x in xs expr ...)
     (letrec ((iter (lambda (l)
                      (if (not (null? l))
                          (begin
                             (let ((x (car l)))
                               (list expr ...))
                             (iter (cdr l)))))))
           (iter (car (list xs)))) )
   ((for xs as x expr ...)
     (letrec ((iter (lambda (l)
                      (if (not (null? l))
                          (begin
                             (let ((x (car l)))
                               (list expr ...))
                             (iter (cdr l)))))))
           (iter (car (list xs)))) )))

(define-syntax while
  (syntax-rules ()
    ((while s expr ...)
     (letrec ((iter (lambda ()
                      (if s
                          (begin
                             (list expr ...)
                             (iter))))))
           (iter)))))

(define-syntax repeat
  (syntax-rules (until)
    ((repeat (expr ...) until cond?)
     (letrec ((iter (lambda ()
                      (if (not cond?)
                          (begin
                             (list expr ...)
                             (iter))))))
           (begin
             (list expr ...)
             (iter))))))

(define-syntax cout
  (syntax-rules ()
    ((cout args ...)
    (letrec ((iter (lambda (l i)
                     (if (not (null? l))
                       (begin
                         (if (even? i)
                             (if (equal? (car l) 'endl)
                                 (newline)
                                 (display (car l))))
                         (iter (cdr l) (+ i 1)))))))
        (iter (list 'args ...) 1)))))