nd does so using using the same `equal?' recursively, so
     a deep structure can be traversed.

          (equal? (list 1 2 3) (list 1 2 3))   ==> #t
          (equal? (list 1 2 3) (vector 1 2 3)) ==> #f

     For other objects, `equal?' compares as per `eqv?', which means
     characters and numbers are compared by type and value (and like
     `eqv?', exact and inexact numbers are not `equal?', even if their
     value is the same).

          (equal? 3 (+ 1 2)) ==> #t
          (equal? 1 1.0)     ==> #f

     Hash tables are currently only compared as per `eq?', so two
     different tables are not `equal?', even if their contents are the
     same.

     `equal?' does not support circular data structures, it may go into
     an infinite loop if asked to compare two circular lists or similar.

     New application-defined object types (Smobs) have an `equalp'
     handler which is called by `equal?'.  This lets an application
     traverse the contents or control what is considered `equal?' for
     two such objects.  If there's no handler, the default is to just
     compare as per `eq?'.