              (save-excursion
                (shm/goto-parent)
                (forward-sexp)
-               (1+ (current-column)))))
+               (1+ (current-column))))
+            (previous
+             (when (looking-back " ")
+               (save-excursion
+                 (search-backward-regexp "[ ]+"
+                                         (line-beginning-position)
+                                         t
+                                         1)
+                 (let ((prev (shm-current-workable-node)))
+                   (when (and (= (car (shm-node-parent prev))
+                                 (car parent-pair))
+                              (/= (shm-node-start parent)
+                                  (shm-node-start (cdr prev))))
+                     prev))))))
         (cond
-
+         (previous
+          (newline)
+          (indent-to (shm-node-start-column (cdr previous))))
          ((and (or (= column (current-column))
                    (= column (+ (shm-node-start-column parent)
                                 (shm-indent-spaces))))

  (let* ((parent-pair (shm-node-parent current-pair))
         (parent (cdr parent-pair))
         (current (cdr current-pair)))
    (cond

     (t (if parent
            (if (and (= (shm-node-start current)
                        (shm-node-start parent))
                     (= (shm-node-end current)
                        (shm-node-end parent)))
                (if (string= (shm-node-type current) (shm-node-type parent))
                    current-pair
                  (shm-workable-node parent-pair))
              current-pair)
          current-pair)))))

(defun shm-node-previous (node-pair)
  "Get the previous node of NODE-PAIR."

       (lambda ()
         (insert newline-string)))))
   ;; Otherwise just do the indent.
   (t (shm/reparse)
      (shm-newline-indent nil)))
  (shm/reparse))

(defun shm/goto-where ()
  "Either make or go to a where clause of the current right-hand-side."
