Function arguments and interactive

Question

I am having difficulty seeing how to properly use function arguments with the interactive command.

Suppose I have a function with three arguments myfunc (arg1 &optional arg2 arg3), the last two being optional. In what circumstances does one need the interactive part to fill the values for arg1, arg2 and arg3?

In the case of the prefix argument, does one need to include the prefix argument as a function argument?

It looks to me that besides make a function into interactive command, the interactive expression provides a mechanism for passing arguments to the function when called interactively.

(defun change-theme (theme)
  (interactive "a Theme Name: ")
  ...)

(defun history (&optional prefix)
  (interactive "P"))

But then one can use things like completing-read and read-from-minibuffer that can be saved to a variable. This gives the same utility as interactive does for the user to enter some input.

(defun cursor-setting ()
  (interactive)
  (let* ( (cseq '("bar" "hbar" "hollow" "box"))
          (csel  (completing-read "Cursor: " cseq nil t "box")) ))

But then I can also do

(interactive
 (let ((string (read-string "Foo: " nil 'my-history)))
   (list (region-beginning) (region-end) string)))

where read-string is called inside the interactive command.

One can also use a list as here

(interactive
 (list 
    (read-string "Remote host: ")
    (read-string "Remote filename: ")))

I am finding the interactive command as one of the most complicated to use.

The following is an important example. I would think that although the example works, the implementation is quite bad. Because whilst one can use it interactively, it is not advisable to use it in a non-interactive way because of the call to read-from-minibuffer, even though the function would still work.

I wonder whether it is a requirement for all interactive functions to always allow a non-interactive call.

(defun workbench (&optional prefix)
  "Make new temporary buffer manually using user input."

  (interactive "P")

  (cond

   ;; -------------------------------------------------
   ((equal current-prefix-arg nil)   ; no C-u

    (message "no C-u")
    (setq thote 1))

   ;; -------------------------------------------------
   ((equal current-prefix-arg '(4))  ; C-u

    (message "no C-u")
    (arktika-automated-workbench))

   ;; -------------------------------------------------
   ((equal current-prefix-arg 1)     ; C-u 1

    (message "C-u 1")
    (let* ( (name (read-from-minibuffer " Name: ")) )
      (arktika-automated-workbench name))))

Answer 1

In your case, the interactive form only needs to pass one argument.

For example:

(defun my-func-one (arg1 &optional arg2 arg3)
  (interactive "P")
  (message "%s %s %s" arg1 arg2 arg3))

In the my-func-one case, the interactive form only fills in the arg1 argument. Argument arg2 and arg3 will be set to nil. For example, calling C-u M-x my-func-one RET yields (4) nil nil.

(defun my-func-three (arg1 &optional arg2 arg3)
  (interactive "P\nd\nm")
  (message "%s %s %s" arg1 arg2 arg3))

For my-func-three, the interactive clause pass three arguments, P pass the raw universal argument value, d is the value of the point and m the mark. C-u M-x my-func-three RET could yield (4) 1630 1440.

Some side comments:

• You use interactive to make a function into a command. However, you can still call it as a function.

• If you want to read arguments regardless if you call it as a command or as a function, you could read the arguments in the body of the function. However, in most cases, you would like to design the function so that it gets its input via its arguments. In this case, the interactive clause is only used to read the arguments when the called as a command.

• You can use the code form of interactive when the string form isn's powerful enough. For example, (interactive "d\nm") is equivalent to (interactive (list (point) (mark))). However, in the code form you can use code anyway you want, e.g. read values using auto completion the string form can't handle.