(define (within? x lower upper)
  (and (<= x upper) (>= x lower)))

; rotate-char char amount lower upper -> char
; If char is within lower and upper range, increase char by amount, and if
; it goes over the upper range, then wrap around to the lower range.

(define (rotate-char in amount lower upper)
  (let
      ((in (char->integer in))
       (lower (char->integer lower))
       (upper (char->integer upper)))
    (integer->char
     (if (within? in lower upper) 
         (begin
           (set! in (+ in amount))
           (if (> in upper)
               (+ lower (- in upper) -1) 
               in))
         in))))


(define (rot13 in)
  (cond 
      ((char-lower-case? in) (rotate-char in 13 #\a #\z))
      ((char-upper-case? in) (rotate-char in 13 #\A #\Z))
      (else in)))


; I am not sure I want to think about this for now...
;(define (rotate-char2 in amount lower upper)
;  (let loop ((i in)) 
;    (cond 
;      ((< i lower) (loop (+ i amount)))
;      ((< i upper) i)
;      (else (loop (+ lower (- i upper)))))))

(define (within? x lower upper) 
    (<= lower x upper))

(define (rot13-char c)
  (cond
   ((char-alphabetic? c)
    (let ((upper? (char-upper-case? c))
           (c (char-downcase c)))
      ((if upper?
           char-upcase
           values)
       (integer->char (+ (char->integer #\a)
                         (remainder (+ 13 (- (char->integer c)
                                             (char->integer #\a))) 26))))))
   (else
    c)
   ))

(define (rot13-stream in out)
  (let loop ()
    (let ((ch (read-char in)))
      (when (not (eof-object? ch))
        (display (rot13-char ch) out)
        (loop)))))

#!/usr/bin/env mzscheme

; Special thanks to Vixey in #lispcafe

; within? x lower upper
; Is x is within lower to upper?
(define (within? x lower upper)
  (<= lower x upper))

; wrap-range x lower upper
; If x is above range, it will wrap from lower
; If x is below range, it will wrap from upper
; It will repeat if necessary
(define (wrap-range x lower upper)
  (cond
    ((> x upper) (wrap-range (+ lower (- x upper) -1) lower upper))
    ((< x lower) (wrap-range (- upper (- lower x) -1) lower upper))
    (else x))) 

; rotate-char char amount lower upper -> char
; If char is within lower and upper range, increase char by amount, and if
; it goes over the upper range, then wrap around to the lower range.
(define (rotate-char x amount lower upper)
  (let
      ((x (char->integer x))
       (lower (char->integer lower))
       (upper (char->integer upper)))
    (integer->char
     (if (within? x lower upper) 
         (wrap-range (+ x amount) lower upper)
         x))))

; rot13 x
; Converts char x to its rot13 equivalent
(define (rot13 x)
  (cond 
      ((char-lower-case? x) (rotate-char x 13 #\a #\z))
      ((char-upper-case? in) (rotate-char x 13 #\A #\Z))
      (else x)))

; rot13-string string
; Converts a string to its rot13 equivalent
(define (rot13-string string)
  (list->string (map rot13 (string->list string))))

(define (within? x lower upper)
  (and (<= x upper) (>= x lower)))

(define (wrap-range x lower upper)
  (cond
    ((> x upper) (wrap-range (+ lower (- x upper)) lower upper))
    ((< x lower) (wrap-range (- upper (- lower x)) lower upper))
    (else x))) 

; rotate-char char amount lower upper -> char
; If char is within lower and upper range, increase char by amount, and if
; it goes over the upper range, then wrap around to the lower range.
(define (rotate-char in amount lower upper)
  (let
      ((in (char->integer in))
       (lower (char->integer lower))
       (upper (char->integer upper)))
    (integer->char
     (if (within? in lower upper) 
         (wrap-range (+ in amount) lower upper)
         in))))


(define (rot13 in)
  (cond 
      ((char-lower-case? in) (rotate-char in 13 #\a #\z))
      ((char-upper-case? in) (rotate-char in 13 #\A #\Z))
      (else in)))


; I am not sure I want to think about this for now...
;(define (rotate-char2 in amount lower upper)
;  (let loop ((i in)) 
;    (cond 
;      ((< i lower) (loop (+ i amount)))
;      ((< i upper) i)
;      (else (loop (+ lower (- i upper)))))))

(define (rotate-char in amount lower upper)
  (let
      ((in (char->integer in))
       (lower (char->integer lower))
       (upper (char->integer upper)))
    (integer->char
     (if (within? in lower upper) 
         (begin
           (set! in (+ in amount))
           (wrap-range in lower upper)
         in)))))

(define (wrap-range x lower upper)
  (cond
    ((> x upper) (wrap-range (+ lower (- x upper)) lower upper))
    ((< x lower) (wrap-range (- upper (- lower x)) lower upper))
    (else x))) 

(define (wrap-range x lower upper)
  (let loop ('())
  (cond
    ((> x upper) (loop (+ lower (- x upper))))
    ((< x lower) (loop (- upper (- lower x))))
    (else x))))