(define palindrome
  (lambda (str)
    (let ((len-1 (sub1 (string-length str))))
      (or (<= len-1 0)
	  (and (char=? (string-ref str 0) (string-ref str len-1))
	       (palindrome (substring str 1 len-1)))))))

(define string-reverse
  (lambda (str)
    (let ((len (string-length str)))
      (if (<= len 1)
          str
          (string-append (string-reverse (substring str 1 len))
	                 (string (string-ref str 0)))))))
                         

;; Written using string-reverse
(define palindrome
  (lambda (str)
    (string=? str (string-reverse str))))

(define sexpr->string
  (lambda (s)
    (cond ((null? s) "()")
          ((list? s)
           (string-append 
            "("
            (sexpr->string (car s))
            (cdr->string (cdr s))
            ")"))
          ((pair? s)
           (string-append
            "("
            (sexpr->string (car s))
            " . "
            (sexpr->string (cdr s))
            ")"))
          (else ;; must be atom.
           (atom->string s)))))

(define cdr->string
  (lambda (ls) ;; Assumes argument is list.
    (if (null? ls)
        ""
        (string-append
         " "
         (sexpr->string (car ls))
         (cdr->string (cdr ls))
         ))))

(define atom->string
  (lambda (s)
    (cond ((number? s)
           (number->string s))
          ((symbol? s)
           (symbol->string s))
          (s "#t")
          (else "#f"))))

(define string-car
  (lambda (str)
    (string (string-ref str 0))))

(define string-cdr
  (lambda (str)
    (substring str 1 (string-length str))))