          (save-excursion (goto-char (line-beginning-position))
                          (shm-in-comment)))
     nil)
+   ((save-excursion
+      (goto-char (line-beginning-position))
+      (or (looking-at "^-}$")
+          (looking-at "^{-$")))
+    nil)
    ;; Otherwise we just do our line-based hack.
    (t
     (save-excursion
       (let ((start (or (progn (goto-char (line-end-position))
-                              (search-backward-regexp "^[^ \n]" nil t 1))
+                              (search-backward-regexp "^[^ \n]" nil t 1)
+                              (unless (or (looking-at "^-}$")
+                                          (looking-at "^{-$"))
+                                (point)))
                        0))
             (end (progn (goto-char (1+ (point)))
                         (or (when (search-forward-regexp "[\n]+[^ \n]" nil t 1)



;; Type information operations

(defun shm-present-type-info (node info)

    (cond
     ((shm-in-comment)
      (insert " "))
     (shm-auto-insert-skeletons
      (cond
       ((looking-back "[^a-zA-Z0-9_]case")
        (shm-auto-insert-case))
       ((looking-back "[^a-zA-Z0-9_]if")
        (shm-auto-insert-if))
       ((and (looking-back "[^a-zA-Z0-9_]let")
             (let ((current (shm-current-node)))
               (not (or (eq 'Do (shm-node-cons current))
                        (string= "Stmt" (shm-node-type-name current))))))
        (shm-auto-insert-let))
       ((and (looking-back "module")
             (= (line-beginning-position)
                (- (point) 6))
             (looking-at "[ ]*$"))
        (shm-auto-insert-module))
       (t (shm-insert-string " "))))
     (t (shm-insert-string " ")))))

(defun shm/jump-to-slot ()
