Re: Placement of list within an interactive clause

[Christopher Dimech <dimech@gmx.com>]

> Sent: Friday, July 15, 2022 at 10:14 PM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: carlmarcos@tutanota.com, "Help Gnu Emacs" <help-gnu-emacs@gnu.org>
> Subject: Re: Placement of list within an interactive clause
>
> * Christopher Dimech <dimech@gmx.com> [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.

You can call it within lisp code for sure.  With interactive to set function 
arguments, you are also correct.  In the broader context of considering
any input from minibuffer as user interactive, it could make some problems.  


 
> So this is the way to go:
> 
> (defun my-fun-2 (&optional name)
>   (interactive)
>   (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
> context.
> 
> 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
> key. 
> 
> 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
> language.
> 
> 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)
>   (interactive)
>   (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.
> `----
> 
> 
> -- 
> Jean
> 
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
> 
> In support of Richard M. Stallman
> https://stallmansupport.org/
> 
>