Re: Is there way to read function invoked and its parameters?

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor 
<help-gnu-emacs@gnu.org> [2020-12-27 21:41]:
> Drew Adams wrote:
> 
> >> Would this concept be possible in Emacs Lisp:
> >> 
> >> (defun my-function (arg &optional arg-1 arg-2)
> >>   (call-other-function (this-function-called parameters-to-this-function)))
> >> 
> >> Then the other function would receive something like
> >> 
> >>  (my-function ARGUMENTS)
> >
> > Reading quickly, so perhaps not understanding the request.
> > But I'm guessing that advice is what you're looking for.
> 
> I'm not understanding either.
> 
> What do you mean by "this-function-called"?
> 
> You can pass a function as an argument, of course, if that is
> the focus point. (it is known by many names, sometimes
> "higher-order programming", sometimes "Aggregate functions",
> sometimes list or set functions - but to us Lispers it is so
> natural it doesn't need a name IMO)
> 
> If it is about passing arg-1 and arg-2 you can use arg &rest
> args and then concatenate them or by using backquote:
> 
> (defun add-all (first &rest rest)
>   (apply `(+ ,@(cons first rest))) )
> 
> (add-all 1)       ;  1
> (add-all 1 3)     ;  4
> (add-all 1 3 3 7) ; 14
> 
> Or do it some other way with &rest

I know I can pass stuff through arguments and I know I could hard code
for each function how it is called. I was rather thinking that maybe
there is functionality where function from inside knows how it was
called and by which arguments. Maybe there is some global variable or
function holding that information. Then I could just pass that
variable to function invoked from that function. Then I would not need
to hard code passing of arguments in hundreds of functions.

Practically I wish to achieve this:

1. Reporting function is invoked, I would like to have program
   remember WHICH reporting function was invoked and by which
   arguments and to pass it to other functions.

2. Other function is called, there are few more hops.

3. The report is shown on screen. Now this reporting function is
   disconnected from the first and I would need a refresh of the
   report after editing or inserting information. The refresh shall
   know exactly how the first reporting function has been invoked.

There are many functions that are at (1) so there is considerable
number of those functions.

For example this is such function that introspect the function being
called:

called-interactively-p is a compiled Lisp function in ‘subr.el’.

(called-interactively-p KIND)

  Probably introduced at or before Emacs version 22.1.

Return t if the containing function was called by ‘call-interactively’.

Maybe there is other mechanism that introspects the function's own name
and function's own arguments.

Then I could do just this:

(defun report (arg1 arg2 arg3)
  (do some stuff)
  (invoke-display (how-this-function-was-called)))

(defun report-1 (arg1 arg2 arg3)
  (do some stuff)
  (invoke-display (how-this-function-was-called)))

(defun report-2 (arg1 arg2 arg3)
  (do some stuff)
  (invoke-display (how-this-function-was-called)))

Instead of doing this:

(defun report (arg1 arg2 arg3)
  (do some stuff)
  (invoke-display '(report arg1 arg2 arg3)))
  
(defun report-1 (arg1 arg2 arg3)
  (do some stuff)
  (invoke-display '(report-1 arg1 arg2 arg3)))

(defun report-2 (arg1 arg2 arg3)
  (do some stuff)
  (invoke-display '(report-2 arg1 arg2 arg3)))

Additionally, it becomes very tedious if I would now need to replace
normal arguments with &rest only for those functions with parameters
to be passed correctly.

I rather prefer having introspection function that looks into itself
and finds out what is its name and what were arguments.