   nil
   " ‘_’"
   (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "C-c C-k C-h") 'th-resolve-hole-via-hoogle-here)
-    (define-key map (kbd "C-c C-k C-b") 'th-insert-relevant-binding-here)
-    (define-key map (kbd "C-c C-k C-f") 'th-new-function-from-hole-here)
+    (define-key map (kbd "C-c C-k C-h") 'th-resolve-hole-hoogle-here)
+    (define-key map (kbd "C-c C-k C-b") 'th-resolve-hole-relevant-bindings-here)
+    (define-key map (kbd "C-c C-k C-f") 'th-resolve-hole-new-function-here)
     (define-key map (kbd "C-c C-k C-t") 'th-toggle-type-hole-undefined-line)
     map))
 

[[:space:]]*(" " (" bindings))))))
        cleaned-bindings))))


(defun th-insert-relevant-binding (str)
  (let* ((bindings (append '("undefined :: a")
                           (th-relevant-hole-bindings str)
                           '( "_ . _ :: composition" "_ $ _ :: application")))
         (binding (funcall completing-read-function "Which binding?: " bindings)))
    (th--replace-type-hole binding)))

(defun th--replace-type-hole (binding)
  (let ((name (th--binding-extract-name binding)))
    (if (looking-at "_")
        (progn (delete-char 1)
               (insert (if th-insert-argument-holes
                           (s-join " " `(,name
                                         ,@(-repeat (th--num-of-args binding) "_")))
                         name))

      (newline 1)
      (delete-blank-lines))))

(defun th-resolve-hole-new-function-here (arg)
  "With one prefix arg (C-u), insert parentheses, with two (C-u C-u) insert parens and argument holes"
  (interactive "p")
  (let ((add-parens (>= arg 4))
        (add-arg-holes (>= arg 16)))
    (th-resolve-hole-new-function
     (funcall th-get-type-hole-info-function) add-parens add-arg-holes)))

(defun th-relevant-hole-bindings (str)
  (with-temp-buffer
