           (with-current-buffer caml-types-buffer
             (erase-buffer)
             (insert kind)
-            (message (format "%s call" kind)))
-          ))))
+            (message (format "%s call" kind)))))))
     (if (and (= arg 4)
              (not (window-live-p (get-buffer-window caml-types-buffer))))
         (display-buffer caml-types-buffer))
     (unwind-protect
         (caml-sit-for 60)
-      (delete-overlay caml-types-expr-ovl)
-      )))
+      (delete-overlay caml-types-expr-ovl))))
 
 (defun caml-types-show-ident (arg)
   "Show the binding of identifier at point.
-   The identifier that contains point is
-   temporarily highlighted.  Its binding is highlighted in the .annot
-   file and the mark is set to the beginning of the binding.
-   The binding is also displayed in the mini-buffer.
+
+The identifier that contains point is temporarily highlighted.
+Its binding is highlighted in the .annot file and the mark is set
+to the beginning of the binding.  The binding is also displayed
+in the mini-buffer.
 
 The binding is also displayed in the buffer *caml-types*, which is
 displayed when the command is called with Prefix argument 4.
 
-See `caml-types-location-re' for annotation file format.
-"
+See `caml-types-location-re' for annotation file format."
   (interactive "p")
   (let* ((target-buf (current-buffer))
          (target-file (file-name-nondirectory (buffer-file-name)))

                         (setq limits
                               (caml-types-find-interval target-buf
                                                         target-pos node)
                               type (cdr (assoc "type" (elt node 2))))
                         ))
                        )
                       (setq mes (format "type: %s" type))
                       (insert type)
                       ))
                   (message mes)
                   )
                  )
                 ;; we read next event, unless it is nil, and loop back.
                 (if event (setq event (caml-read-event)))
                 )
               )
            ;; delete overlays at end of exploration
            (delete-overlay caml-types-expr-ovl)
            (delete-overlay caml-types-typed-ovl)
            ))
      ;; When an error occurs, the mouse release event has not been read.
      ;; We could wait for mouse release to prevent execution of
      ;; a binding of mouse release, such as cut or paste.

(make-variable-buffer-local 'caml-types-annotation-date)

(defvar caml-types-buffer-name "*caml-types*"
  "Name of buffer for displaying caml types.")
(defvar caml-types-buffer nil
  "Buffer for displaying caml types.")

(defun caml-types-show-type (arg)
  "Show the type of expression or pattern at point.

The smallest expression or pattern that contains point is
temporarily highlighted.  Its type is highlighted in the .annot
file and the mark is set to the beginning of the type.  The type
is also displayed in the mini-buffer.

Hints on using the type display:
. If you want the type of an identifier, put point within any
occurrence of this identifier.
. If you want the result type of a function application, put
point at the first space after the function name.  . If you want
the type of a list, put point on a bracket, on a semicolon, or on
the :: constructor.
. Even if type checking fails, you can still look at the types
in the file, up to where the type checker failed.

Types are also displayed in the buffer *caml-types*, which is
displayed when the command is called with Prefix argument 4.

See also `caml-types-explore' for exploration by mouse dragging.
See `caml-types-location-re' for annotation file format."
  (interactive "p")
  (let* ((target-buf (current-buffer))
         (target-file (file-name-nondirectory (buffer-file-name)))
