         (forward-char))
     (newline-and-indent)
     ;; Indent the following S-expression, but don't signal an error if
-    ;; there's only a closing parenthesis after the point.
+    ;; there's only a closing delimiter after the point.
     (paredit-ignore-sexp-errors (indent-sexp))))
+
+(defun paredit-reindent-defun (&optional argument)
+  "Reindent the definition that the point is on.
+If the point is in a string or a comment, fill the paragraph instead,
+  and with a prefix argument, justify as well."
+  (interactive "P")
+  (if (or (paredit-in-string-p)
+          (paredit-in-comment-p))
+      (fill-paragraph argument)
+    (save-excursion
+      (beginning-of-defun)
+      (indent-sexp))))
  
 ;;;; Comment Insertion

        (backward-char)))
    oddp))

(defun paredit-in-char-p (&optional arg)
  "True if the point is immediately after a character literal.
A preceding escape character, not preceded by another escape character,
  is considered a character literal prefix.  (This works for elisp,

           (delete-char 1)))))

(defun paredit-backward-delete (&optional argument)
  "Delete a character backward or move backward over a delimiter.
If on a closing S-expression delimiter, move backward into the
  S-expression.
If on an opening S-expression delimiter, refuse to delete unless the
  S-expression is empty, in which case delete the whole S-expression.
With a numeric prefix argument N, delete N characters backward.
With a `C-u' prefix argument, simply delete a character backward,
  without regard for delimiter balancing."
  (interactive "P")
  (cond ((or (consp argument) (bobp))
         ;++ Should this untabify?
         (backward-delete-char 1))
        ((integerp argument)
         (if (< argument 0)
             (paredit-forward-delete (- 0 argument))
             (while (> argument 0)
               (paredit-backward-delete)
               (setq argument (- argument 1)))))
        ((paredit-in-string-p)
         (paredit-backward-delete-in-string))
        ((paredit-in-comment-p)
