Of course it is possible inclusive the interactive specification. We are dealing here with elisp! (Lisp is the language where the most important constructs are lists. Callable forms are just lists. So you can construct them after your liking.)
Application: You want to add some functionality to some functions automagically. The extended functions should be ...
I had to solve a very similar problem in nadvice.el, so here is a solution (which uses some of the code from nadvice.el):
(defun wrapper (&rest args)
(cadr (interactive-form #'wrappee))))
(apply #'wrappee args))
Compared to the other solutions posted so far, this one has the advantage of ...
As @hatschipuh pointed out in the comments, an flet-type construction is more straightforward and doesn't rely on my idiosyncratic advice macro. At least on my Emacs (24.5.1), cl-flet uses lexical scoping, so you'll need the noflet package for the following snippet to work. Scroll down for the original, idiosyncratic answer.
The error is (add-to-list return nil). The first argument of add-to-list must be the symbol of the variable holding the list and not the list itself.
That means you have to write (add-to-list 'return nil) instead.
You can find such errors easily yourself if you use edebug.
I think you have lisp-interaction-mode or emacs-lisp-mode as major mode of the buffer ...
Emacs Lisp doesn't have any support for automatic type checking, whether in the byte compiler or at runtime.
The idiomatic way to report an error at runtime is to check the argument against a predicate function, and signal the error `wrong-type-argument if it doesn't match.
Furthermore, to express a choice between a small, fixed number of items, the ...
This seems unfortunate in that, in order to produce a similar effect, it's necessary to copy-paste code: [...] I can copy ansi-term's interactive form
On the contrary, I think it would be a good idea to copy-paste the interactive form of the advised function, even though you don't actually have to do so here.
I read you question from top to bottom. When I ...
I generally recommend against doing that (better change the functions to take &optional or &rest arguments that are simply ignored), but if you must, the solution I recommend is:
(funcall f arg1 arg2 arg3)
(funcall f arg1 arg2)
No, there is no reason not to pass a non-nil value that has some other meaning (to a human reader, if not to the executing code).
It is common to do this, especially when there are multiple parameters, and especially if some are used in some call which are not used very often. That can help a (human) reader understand without needing to use C-h f to consult ...
The function sunrise-sunset is an interactive function takes a numeric prefix argument as a parameter. It does not take the latitude and longitude as parameters, which is what you're trying to pass into it. I suggest reading this emacs wiki article as well as of course the manual itself to learn more about prefix arguments. Also checking out the interactive ...
Standard elisp does not allow you to put restrictions on the arguments in the header in the way you're specifying, but you may wish to check out cl-defun in the Common Lisp extension library to get more options in your defuns.
In the meantime, a fairly simple way to handle your use case is to do a preliminary check before you get into the body of the ...
You can use func-arity added in 26.1. C-h f func-arity:
func-arity is a built-in function in `C source code'.
Return minimum and maximum number of args allowed for FUNCTION.
FUNCTION must be a function of some kind.
The returned value is a cons
cell (MIN . MAX).
MIN is the minimum number of args.
MAX is the
A simple way to differentiate between value nil and a missing optional argument is to use &rest instead of &optional.
I demonstrate that with the following test function:
(defun testfun (arg &rest optArgs)
"Do something with ARG, OPT1, and OPT2.
OPT1 and OPT2 can be nil, 1, and 2.
The default of OPT1 is 1 and the default of 2 is 2.
\(fn ARG &...
cl-defun handles this usecase:
(cl-defun test (&key foo bar)
(list foo bar))
(test :foo 1 :bar 2) ; (1 2)
(test :foo 1 :bar 2 :baz 3) ; Error: "Keyword argument :baz not one of (:foo :bar)"
In case you want the opposite behavior, pass &allow-other-keys after the key list.
You've misunderstood the error. Emacs is complaining about the call to your function eshell-go-to-number-down; not the call to evil-numbers/inc-at-pt.
Your problem is that you have defined a function with an empty arglist (), and then given it an interactive spec of "p*" -- which supplies an argument when the function is called interactively.
See C-h f ...
Something like this, the new function to learn is apply:
(defun get-quotes (x &rest y)
(cons x y))
"Smith, \"Neural Pathways in Cat Brains\""
(dolist (thisarticle articles)
(if (stringp thisarticle)
org-agenda-todo calls the org-todo function interactively and in doing so, the it passes its own argument as it is to org-todo1.
From C-h f org-todo, you will get a complete understanding of what the values of ARG mean to org-todo (and org-agenda-todo):
org-todo is an interactive compiled Lisp function in `org.el'.
(org-todo &optional ARG)
Change the ...
As documented in the Info for Elisp:
The argument SYMBOL is not implicitly quoted; add-to-list is an
ordinary function, like set and unlike setq. Quote the
argument yourself if that is what you want.
Here's a scenario showing how to use add-to-list:
(setq foo '(a b))
=> (a b)
(add-to-list 'foo 'c) ;; Add `c'.
=> (c a ...
Another possible solution:
(defun neotree-go-to-upper-directory ()
(evil-define-key 'normal neotree-mode-map (kbd "h")'neotree-go-to-upper-directory)
call-interactively invokes the function exactly as it would have been with a keybinding, so it should work, in theory ...
There is the general rule that any widely used programming language such as R has an Emacs language mode and those modes also have functions that parse function arguments. For R there is the huge package Emacs Speaks Statistics.
There is a parser ess-r-syntax. The comment marks it as "not yet stable". But, there are 4 people working on it including senior ...
It looks like you can call it like this:
(let ((calendar-latitude 40.1)
(calendar-location-name "Urbana, IL"))
This does not prompt you for the latitude and longitude, and puts a message in the minibuffer for those variable values.
set-mark-command (as the name suggests) is meant to be used as a command and not called as a function. For that reason, the docstring talks about the interactive uses rather than the case where you call it from Elisp code.
Once you're familiar with the "universal prefix argument" in Elisp, you can mostly decode the above docstring and guess that ARG will ...
Not exactly. Function buffer-substring requires two arguments. Function - will accept a single argument, but in that case it just returns the negative of that numeric argument. What you want to do is, in effect, apply such functions to a list of arguments. You can use higher-order function apply to do that.
What you can do, if you want, is have a macro or ...
cl-defun from cl-macs.el allows you to specify default values (beside much other mind-blowing stuff).
(cl-defun testfun (arg &optional (opt1 1) (opt2 2))
"Process normal ARG and optional args OPT1 and OPT2 with defaults 1 and 2, respectively."
(list arg opt1 opt2))
Test 1: Set opt2 explicitly to nil:
(testfun 1 'a nil)
(1 a nil)
Test 2: Setting ...
2nd Edit: Turns out there is a builtin, func-arity. It works exactly like the lambda-arity included below. Might be worth checking if it's defined in your emacs 25 though.
1st Edit: having re-read your use-case, maybe just do (if (< (string-to-number emacs-version) ... instead.
Not built-in, no. There's help-function-arglist which returns the signature, ...
In Lisp, the term/word that follows an open parenthesis (if the open parenthesis is not quoted) is interpreted to be a function, not a variable. In the context of this question, to is a variable. Because the word to follows an open parenthesis that is not quoted, Emacs thinks it was meant to be interpreted as a function instead of a variable. Try instead ...
Under the theory that some answer is better than none, I've posted my hacky solution to this, however I would welcome a better answer than this one.
(defun find-next-fcn-arg-separator ()
"Find the next argument separator in a function call.
Move point to the next function argument separator. Point is
expected to be at the opening parenthesis of the ...