`call-interactively' only the first time

`call-interactively' only the first time

[augukarl]

Hi everyone,

Is it possible to write a function that first calls a function, f,
interactively and then invokes f with the same parameters
non-interactively?


Regards,

August

Re: `call-interactively' only the first time

[wenbinye]

If use (call-interactively 'f), the function is interactively.
if provide parameters to the function, such (f 1), the function f is
like other functions.
Is this the answer?
augukarl@yahoo.se wrote:
> Hi everyone,
>
> Is it possible to write a function that first calls a function, f,
> interactively and then invokes f with the same parameters
> non-interactively?
> 
> 
> Regards,
> 
> August

Re: `call-interactively' only the first time

[augukarl]

wenbinye@gmail.com skrev:

> If use (call-interactively 'f), the function is interactively.
> if provide parameters to the function, such (f 1), the function f is
> like other functions.
> Is this the answer?

Unfortunately, no.

I first want to call a function interactively and then I want to call
the same function non-interactively. In the non-interactive call I want
to pass the same parameters used with the preceding interactive call.


August

Re: `call-interactively' only the first time

[wenbinye]

Can you give the definition of the function?
augukarl@yahoo.se wrote:
> wenbinye@gmail.com skrev:
>
> > If use (call-interactively 'f), the function is interactively.
> > if provide parameters to the function, such (f 1), the function f is
> > like other functions.
> > Is this the answer?
>
> Unfortunately, no.
>
> I first want to call a function interactively and then I want to call
> the same function non-interactively. In the non-interactive call I want
> to pass the same parameters used with the preceding interactive call.
> 
> 
> August

Re: `call-interactively' only the first time

[augukarl]

wenbinye@gmail.com skrev:
> Can you give the definition of the function?

Here is the pseudo code for the function I want to define:

(defun f (g)  ;; g is an interactive function.
  ;; Call g interactively.
  ;; Call g non-interactively with the parameters (specified by
  ;; the user) in the command above.
  )

Is this clear enough?


Thanks,

August

Re: `call-interactively' only the first time

[wenbinye]

You didn't provide the real code, I assume you may make mistake when
use
the function in parameter, which is named g in you pseudo code. You
should
use funcall function.
Another question is how do you restore the argument when called
interactively first time?

(defun foo (arg)
  (interactive "sGive me a string: ")
  (message "foo: %S" arg))

(defun bar (func)
    (message "first call: ")
    (call-interactively func)
    (message "call again: ")
    (funcall func "efg"))

;; use like this:
(bar 'foo)

augukarl@yahoo.se wrote:
> wenbinye@gmail.com skrev:
> > Can you give the definition of the function?
>
> Here is the pseudo code for the function I want to define:
>
> (defun f (g)  ;; g is an interactive function.
>   ;; Call g interactively.
>   ;; Call g non-interactively with the parameters (specified by
>   ;; the user) in the command above.
>   )
> 
> Is this clear enough?
> 
> 
> Thanks,
> 
> August

Re: `call-interactively' only the first time

[augukarl]

wenbinye@gmail.com skrev:
> You didn't provide the real code,

Of course not. My question is how to write it.

> I assume you may make mistake when use
> the function in parameter, which is named g in you pseudo code. You
> should use funcall function.

How can it be a misstake? I haven't written any (real) function-call
statements.

> Another question is how do you restore the argument when called
> interactively first time?

Exactly, that's the essence of my question.

> (defun foo (arg)
>   (interactive "sGive me a string: ")
>   (message "foo: %S" arg))
>
> (defun bar (func)
>     (message "first call: ")
>     (call-interactively func)
>     (message "call again: ")
>     (funcall func "efg"))
>
> ;; use like this:
> (bar 'foo)

This is only a special case. In my pseudo code I put no restrictions on
the command g (it can take any number of parameters).


August

Re: `call-interactively' only the first time

[wenbinye]

Maybe I misunderstand you question. You should tell you real problem at
the beginning.

(defun foo (arg1 arg2)
  (interactive "nNumber: \nsString: \n")
  (message "foo: %S, %S" arg1 arg2)
  (setq my-global-arg (list arg1 arg2)))

(defun bar (func)
  (let (arg)
    (message "first call: ")
    (call-interactively func)
    (message "call again: ")
    (apply func my-global-arg)))

(bar 'foo)

augukarl@yahoo.se wrote:
> wenbinye@gmail.com skrev:
> > You didn't provide the real code,
>
> Of course not. My question is how to write it.
>
> > I assume you may make mistake when use
> > the function in parameter, which is named g in you pseudo code. You
> > should use funcall function.
>
> How can it be a misstake? I haven't written any (real) function-call
> statements.
>
> > Another question is how do you restore the argument when called
> > interactively first time?
>
> Exactly, that's the essence of my question.
Global variable may help.
>
> > (defun foo (arg)
> >   (interactive "sGive me a string: ")
> >   (message "foo: %S" arg))
> >
> > (defun bar (func)
> >     (message "first call: ")
> >     (call-interactively func)
> >     (message "call again: ")
> >     (funcall func "efg"))
> >
> > ;; use like this:
> > (bar 'foo)
>
> This is only a special case. In my pseudo code I put no restrictions on
> the command g (it can take any number of parameters).
> 
> 
> August