(define-syntax or
  (syntax-rules ()
    ((_) #f)
    ((_ e1 e2 ...)
     (let ((t e1))
       (if t t (or e2 ...))))))

(define-syntax or
  (syntax-rules ()
    ((_) #f)
    ((_ e) e)
    ((_ e1 e2 e3 ...)
     (let ((t e1))
       (if t t (or e2 e3 ...))))))

(define-syntax or
  (syntax-rules ()
    ((_) #f)
    ((_ e1 e2 ...)
     (let ((t e1))
       (if t t (or e2 ...))))))

(define-syntax or1
  (syntax-rules ()
    ((_) #f)
    ((_ e) e)
    ((_ e1 e2 e3 ...)
     (let ((t e1))
       (if t t (or1 e2 e3 ...))))))

(define (if x y z) (error ""))

(or false) ; ошибка
(or1 false) ; нет ошибки

  (define-syntax or1
    (syntax-rules ()
      ((_) #f)
      ((_ e1 e2 ...)
       (let ((t e1))
         (if t t 
             (or1 e2 ...))))))
  
  (define-syntax or2
    (syntax-rules ()
      ((_) #f)
      ((_ e) e)
      ((_ e1 e2 e3 ...)
       (let ((t e1))
         (if t t (or2 e2 e3 ...))))))

  (or1 'a 'b 'c 'd)
  ;  =>  
  ;  (let ((t1 'a))
  ;    (if t1 t1 
  ;        (let ((t2 'b)) 
  ;          (if t2 t2 
  ;              (let ((t3 'c)) 
  ;                (if t3 t3 
  ;                    (let ((t4 'd))
  ;                      (if t4 t4 #f))))))))
  
  (or2 'a 'b 'c 'd)
  ;  =>  
  ;  (let ((t1 'a)) 
  ;    (if t1 t1 
  ;        (let ((t2 'b)) 
  ;          (if t2 t2 
  ;              (let ((t3 'c)) 
  ;                (if t3 t3 'd))))))

(or <test> ...)
Syntax: The <test>s must be expressions.
Semantics: If there are no <test>s, #f is returned. Otherwise, the <test> expressions are evaluated from left to right until a <test> returns a true value val (see section 5.7) or the last <test> is reached. In the former case, the or expression returns val without evaluating the remaining expressions. In the latter case, the last expression is evaluated and its values are returned.

(or (= 2 2) (> 2 1)) => #t
(or (= 2 2) (< 2 1)) => #t
(or #f #f #f)        => #f
(or '(b c) (/ 3 0))  => (b c)

The or keyword could be defined in terms of if using syntax-rules (see section 11.19) as follows:

(define-syntax or
  (syntax-rules ()
    ((or) #f)
    ((or test) test)
    ((or test1 test2 ...)
     (let ((x test1))
       (if x x (or test2 ...))))))

The last <test> expression is in tail context if the or expression itself is; see section 11.20.

(or2 #f #f #f "hello, world!")

(define fail (vector 'fail))

(We take you now to the Oval Office.)
George: Condi! Nice to see you. What's happening?
Condi: Sir, I have the report here about the new leader of China.
George: Great. Lay it on me.
Condi: Hu is the new leader of China.
George: That's what I want to know.
Condi: That's what I'm telling you.
George: That's what I'm asking you. Who is the new leader of China?
Condi: Yes.
George: I mean the fellow's name.
Condi: Hu.
George: The guy in China.
Condi: Hu.
George: The new leader of China.
Condi: Hu.
George: The Chinaman!
Condi: Hu is leading China.
George: Now whaddya' asking me for?
Condi: I'm telling you Hu is leading China.
George: Well, I'm asking you. Who is leading China?
Condi: That's the man's name.
George: That's who's name?
Condi: Yes.
George: Will you or will you not tell me the name of the new leader of China?
Condi: Yes, sir.
George: Yassir? Yassir Arafat is in China? I thought he was in the Middle East.
Condi: That's correct.
George: Then who is in China?
Condi: Yes, sir.
George: Yassir is in China?
Condi: No, sir.
George: Then who is?
Condi: Yes, sir.
George: Yassir?
Condi: No, sir.
George: Look, Condi. I need to know the name of the new leader of China. Get me the Secretary General of the U.N. on the phone.
Condi: Kofi?
George: No, thanks.
Condi: You want Kofi?
George: No.
Condi: You don't want Kofi.
George: No. But now that you mention it, I could use a glass of milk. And then get me the U.N.
Condi: Yes, sir.
George: Not Yassir! The guy at the U.N.
Condi: Kofi?
George: Milk! Will you please make the call?
Condi: And call who?
George: Who is the guy at the U.N?
Condi: Hu is the guy in China.
George: Will you stay out of China?!
Condi: Yes, sir.
George: And stay out of the Middle East! Just get me the guy at the U.N.
Condi: Kofi.
George: All right! With cream and two sugars. Now get on the phone.
(Condi picks up the phone.)
Condi: Rice, here.
George: Rice? Good idea. And a couple of egg rolls, too. Maybe we should send some to the guy in China. And the Middle East. Can you get Chinese food in the Middle East?

  <UnreadMessages>
    <int>42292</int>
    <int>42298</int>
    <int>42300</int>
  </UnreadMessages>

LCR>(define fail (vector 'fail))
LCR>

LCR>Такое значение будет не eq? любому другому. Ну конечно до тех пор, пока кто-нибудь не переопределит eq? подходящим образом

(define fail? (x) (not (eq? x x)))

LCR>  <UnreadMessages>
LCR>    <int>42292</int>
LCR>    <int>42298</int>
LCR>    <int>42300</int>
LCR>  </UnreadMessages>
LCR>

char c;
while(true)
{
    c = getchar(); // прочитали символ либо признак конца/ошибки - int getchar(void)
    if(c == EOF) break; // EOF - это (int)-1
    printf("<%02X>", (unsigned char)c); // вывели в hex-формате, например
}

<Messages><int>1</int><int>2</int></Messages>                      ---> '((1 2))
<Messages></Messages>                                              ---> '(())
<Messages><int>1</int></Messages><Messages><int>2</int></Messages> ---> '((1) (2)) - если это в принципе допустимо
пусто/облом                                                        ---> '()        - он же nil

К>;(define fail? (x) (not (eq? x x)))
К>;

> (eq? +nan.0 +nan.0)
#t
> (= +nan.0 +nan.0)
#f

К>;(define fail? (x) (not (eq? x x)))
К>;

(define fail (vector 'fail))
(define (fail? x) (eq? x fail))

(fail? 'fail) ;; => #f
(fail? fail)  ;; => #t

К><Messages><int>1</int><int>2</int></Messages> ---> '((1 2))
К><Messages></Messages>                         ---> '(())
К><Messages><int>1</int></Messages>
К><Messages><int>2</int></Messages>             ---> '((1) (2)) - если это в принципе допустимо
К>пусто/облом                                   ---> '()        - он же nil
К>

(let ((l (parse xml))
      (if l
          (do-stuff-with l)
          (display "try again"))))

(let ((l (parse xml))
      (if l ; типа рассматривает пустой список как ложь
          (do-stuff-with (car l)) ; фи!
          (display "try again"))))

  (define if (lambda (x y z) 'omg))
  (display (if 1 2 3)) ; выведет omg

LCR>;  (define if (lambda (x y z) 'omg))
LCR>;  (display (if 1 2 3)) ; выведет omg
LCR>;

LCR>Следоветельно и любое определение Maybe не железобетонно. Конечно, никто специально не отстреливает себе выступающие части тела, переопределяя ради прикола стандартные формы, однако лисперам/схемерам нравится само существование возможности переопределить всё нахрен.

(library (fail)
  (export fail? fail)
  (import (rnrs))
  
  (define fail '#(whatever))
  (define (fail? arg) (eq? fail arg)))

(import (rnrs) (fail))
(define newfail fail)
(list fail (fail? '#(whatever)) (fail? fail) (fail? newfail))
;=> (#(whatever) #f #t #t)

(define eq? 'got-ya)
(fail? fail)
;=> #t

; uncomment to have an exception
;(set! fail #f)

(set! newfail '#(whatever))
(fail? newfail)
;=> #f

(library (fail)
  (export fail? fail)
  (import (rnrs))
  
  (define fail '#(whatever))
  (define (fail? arg) (eq? fail arg)))

(library (fail2)
  (export (rename (fail foo)))
  (import (only (fail) fail)))

(import (only (fail) fail?) (rename (fail2) (foo success)))
(fail? success)
;=> #t

(import (fail) (rename (fail2) (foo success)))
(eq? fail success)
;=> #t

А>;(library (fail)
А>;(define fail '#(whatever))
А>;

(define-record-type (fail-type make-fail fail?))
(define fail (make-fail))