As I understand it, you basically want to run a command in the REPL. That is, I think you're saying you want to press C-M-S-g and have it execute (go) in the REPL.
Emacs interacts with processes through a comint, or command interpreter. For example,
Shell mode is a derivative of Comint mode, a general-purpose mode for communicating with interactive subprocesses. Most of the features of Shell mode actually come from Comint mode...
https://www.gnu.org/software/emacs/manual/html_node/emacs/Shell-Mode.html
The cider REPL must be communicating with a process. Therefore, it must be a comint.
I know next to nothing about Clojure or CIDER. Rather than try to give an answer tailored to those, I will give something general which should address the problem, as I understand it, and be useful elsewhere. This is from my init and is one of my favorite hacks.
A common task for me is copying text from one buffer to another. Sometimes that buffer is just a regular buffer, other times it's a comint. Often, I don't know where I'll need to copy text to. The target must be determined "on demand".
The following defines a new variable, xc/on-demand-window. It defines the target for where text should go. Note that this is defined in terms of windows1. This makes the target location fixed.
(defvar xc/on-demand-window nil "Target on-demand window. An on-demand window is one which you wish to return to within the current Emacs session but whose importance doesn't warrant a permanent binding.")
The next function makes defining the target window more user friendly. Call xc/on-demand-window to set the target to the currently selected window. In your case, once the REPL is up, select that window and call this.
(defun xc/on-demand-window-set () "Set the value of the on-demand window to current window." (interactive) (setq xc/on-demand-window (selected-window)) (message "Set on-demand window to: %s" xc/on-demand-window))
It's handy to jump between the source window and the target. Call xc/on-demand-window-goto to do that.
(defun xc/on-demand-window-goto () "Goto the `xc/on-demand-window'." (interactive) (let ((win xc/on-demand-window)) (unless win (error "No on-demand window set! See `xc/on-demand-window-set'.")) (if (eq (selected-window) xc/on-demand-window) (error "Already in `xc/on-demand-window'")) (let ((frame (window-frame win))) (raise-frame frame) (select-frame frame) (select-window win))))
Ultimately, you want to send text to the REPL. The function xc/send-line-or-region is for interactively sending text. It's a bit of overkill but like I said, it was already in my init. It will send a line or region to the on-demand window (or current window if the on-demand window is not set). If the on-demand window's buffer has no process, the line is simply inserted. However, if the buffer has a process, as should be the case with the REPL, the line will be inserted and sent to the process. It has the added option to insert a new line for non-text buffers.
(defun xc/send-line-or-region (&optional advance buff beg end) "Send region or line to BUFF. If buffer has a process, insert and send line to the process. If no process, then simply insert text at point. Create a new line when ADVANCE is non-nil. Use current region if BEG and END not provided. If no region provided, send entire line. Default BUFF is the buffer associated with `xc/on-demand-window'." (interactive (if (use-region-p) (list nil nil (region-beginning) (region-end)) (list nil nil nil nil))) (let* ((beg (or beg (if (use-region-p) (region-beginning)) nil)) (end (or end (if (use-region-p) (region-end)) nil)) (substr (string-trim (or (and beg end (buffer-substring-no-properties beg end)) (buffer-substring-no-properties (line-beginning-position) (line-end-position))))) (buff (or buff (window-buffer xc/on-demand-window))) (proc (get-buffer-process buff))) (if substr (with-selected-window (get-buffer-window buff t) (let ((window-point-insertion-type t)) ; advance marker on insert (cond (proc (goto-char (process-mark proc)) (insert substr) (comint-send-input nil t)) (t (insert substr) (if advance (progn (end-of-line) (newline-and-indent))))))) (error "Invalid selection"))))
Send a string to the on-demand window with xc/send-string. This is probably more to your question. It works the same way as xc/send-line-or-region, but acts on a fixed string. When called with M-x, it will prompt for what string to send. I also added a history so that you can press up/down or M-p/M-n to see previously sent strings.
(defvar xc--send-string-history nil "History of strings sent via `xc/send-string'") (defun xc/send-string (string &optional advance buff) "Send STRING to BUFF'. Default BUFF is the buffer associated with `xc/on-demand-window' (or current window if not set). If BUFF has an associated process, send region as input, otherwise just insert the region. Create a new line when ADVANCE is non-nil." (interactive (let* ((prompt (format "Send string to % s: " (window-buffer xc/on-demand-window))) (cmd (read-string prompt "" 'xc--on-demand-send-string-history))) (list cmd nil nil))) (let* ((buff (or buff (window-buffer xc/on-demand-window))) (proc (get-buffer-process buff))) (with-selected-window (get-buffer-window buff t) (let ((window-point-insertion-type t)) ; advance marker on insert (cond (proc (goto-char (process-mark proc)) (insert string) (comint-send-input nil t)) (t (insert string) (if advance (progn (end-of-line) (newline-and-indent)))))))))
You can then do what you want with something like:
(global-set-key (kbd "C-M-S-g") '(lambda () (interactive) (xc/send-string "(go)")))
Hopefully that helps! Happy hacking!
NOTE The xc/send-line-or-region and xc/send-string commands use string-trim which doesn't seem to autoload. You may need to call (require 'subr-x) first.
EDIT The previous code handles sending to the REPL. The link you gave on the 5th gives a clue about handling namespaces.
Since namespaces are part of the language used by the comint/REPL, they must be handled within the string sent to the comint/REPL.
I've not used Clojure, but modifying the "essential pattern", the string that needs to be sent is (or is something like):
"(require 'user) (user/go (go))"
So, using xc/send-string,
(global-set-key (kbd "C-M-S-g") '(lambda () (interactive) (xc/send-string "(require 'user) (user/go (go))"))
Honestly, though, it looks like this function from the article you linked would do something comparable if the sexp before point were (go) (and the appropriate some-namespace/some-namespace-fn replacement made):
(defun custom-eval-last-sexp () (interactive) (cider-interactive-eval (format "(require 'some-namespace) (some-namespace/some-fn %s)" (cider-last-sexp))))
Hopefully that's enough for you to modify things to your need.
1 Although we need to send text to a buffer, I've found that it's actually the window I want to interact with. It's somewhat arbitrary since it's possible to get the buffer from a window and vice-versa. I've done it both ways and this is what has survived in my init. Feel free, of course, to try it the other way.
