[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Placement of list within an interactive clause

From: Jean Louis
Subject: Re: Placement of list within an interactive clause
Date: Fri, 15 Jul 2022 13:14:25 +0300
User-agent: Mutt/+ () (2022-06-11)

* Christopher Dimech <> [2022-07-15 11:19]:
> > Thus instead of following:
> > 
> > (defun my-fun-1 (&optional name)
> >   (interactive "MName: ")
> >   (message "Hello %s" name))
> > 
> > I am using following:
> > 
> > (defun my-fun-2 (&optional name)
> >   (interactive)
> >   (let ((name (or name (read-from-minibuffer "Name: "))))
> >     (message "Hello %s" name)))
> > 
> > as that gives me little more freedom:
> > 
> > - if I call (my-fun-1) ⇒ "Hello nil" that result is not what I
> >  really want. It makes it difficult to get the wanted result. To
> >  get the wanted result I need to use:
> > 
> > (call-interactively 'my-fun-1) ⇒ "Hello Bob"
> > 
> > - but if I call (my-fun-2) and NAME is not supplied, I will be
> >   asked for name: (my-fun-2) ⇒ "Hello Bob" and will not get "NIL"
> >   as result. In this case I need not complicate the call and use
> > `call-interactively`.
> > 
> > Additionall, complex `interactive` clauses I find often too
> > difficult to comprehend than reading the body of the function.
> Yes, but you are forced for interactive commands.  It is not equivalent
> to a function that is non-interactive.

You are not forced to supply arguments within (interactive), not at
all. Function may not need any arguments. But if it has prefix you
should declare (interactive "P"). But if it needs some text input you
may say (interactive "MInput: ")

However, I have explained in the above example of mine that such input
may be provided in the function itself. And it looks to me that it is
better handled that way than through `interactive' declaration.

So this is the way to go:

(defun my-fun-2 (&optional name)
  (let ((name (or name (read-from-minibuffer "Name: "))))
    (message "Hello %s" name)))

Function `interactive' DOES NOT make function "interactive" in the
other contexts in English language, there is special meaning in the
Emacs Lisp context. Programming meaning is simply not same to English

To call function interactively, it means not to call it exclusively
from Lisp, but from the user interface by using M-x or key. 

That means, when there is declaration (interactive), that function
becomes accessible through M-x invokation, and it may be bound to a

It means then you can run the function by pressing a key (that is what
is meant with "interactively") or by invoking the function with M-x
or through menus.

IT DOES NOT EXCLUDE that other functions without the declaration
"(interactive)" are and can be "interactive" in the meaning of English

You may thus have a function that is command and that may be invoked
interactively because of declaration "(interactive)":

(defun my-fun-2 (&optional name)
  (let ((name (or name (read-from-minibuffer "Name: "))))
    (message "Hello %s" name)))

And you may have interactive function, that interacts with user
without declaration "(interactive)":

(defun my-fun-3 (&optional name)
  (let ((name (or name (read-from-minibuffer "Name: "))))
    (message "Hello %s" name)))

And that function in the meaning of English language is interactive,
but is not a command in the meaning of Emacs Lisp because it does not
have declaration "(interactive)".

| Specify a way of parsing arguments for interactive use of a function.
| For example, write
|  (defun foo (arg buf) "Doc string" (interactive "P\nbbuffer: ") .... )
|  to make ARG be the raw prefix argument, and set BUF to an existing buffer,
|  when ‘foo’ is called as a command.
| The "call" to ‘interactive’ is actually a declaration rather than a
|  function; it tells ‘call-interactively’ how to read arguments to pass
|  to the function.  When actually called, ‘interactive’ just returns
|  nil.
| Usually the argument of ‘interactive’ is a string containing a code
|  letter followed optionally by a prompt.  (Some code letters do not
|  use I/O to get the argument and do not use prompts.)  To pass several
|  arguments to the command, concatenate the individual strings,
|  separating them by newline characters.
| Prompts are passed to ‘format’, and may use %s escapes to print the
|  arguments that have already been read.
| If the argument is not a string, it is evaluated to get a list of
|  arguments to pass to the command.
| Just ‘(interactive)’ means pass no arguments to the command when
|  calling interactively.


Take action in Free Software Foundation campaigns:

In support of Richard M. Stallman

reply via email to

[Prev in Thread] Current Thread [Next in Thread]