apply partially last arg

Question

Is there something like apply-partially

(apply-partially FUN &rest ARGS)

Return a function that is a partial application of FUN to ARGS.
ARGS is a list of the first N arguments to pass to FUN.
The result is a new function which does the same as FUN, except that
the first N arguments are fixed at the values with with which this
function was called.

But with the "last N arguments are fixed"

Or "all arguments are fixed except wildcard" ie:

(defun foo (a b c))
(defalias 'fix-a-c-in-foo 'apply-partially-wildcard 'foo "a valuel" '_ "c value")

_ - random symbol that means "wildcard"

Answer 1

You have everything you need in the emacs-lisp core language with fset, lambda expressions and backticks. The following source code is an extension of your second example. The comma expression allows you to easily substitute something in a back-tick quoted lambda expression and you can assign that expression to a symbol's function-cell with fset.

(defun foo (a b c d)
  (message "a=%s b=%s c=%s d=%s" a b c d))

(let ((fix-a "a-value"))
  (fset #'fix-a-c-in-foo `(lambda (_d _b) (foo ,fix-a _b "c-value" _d)))
  )

(fix-a-c-in-foo "new-d-value" "new-b-value")

I have added one more argument to foo to have at least two fix parameters and two "template" parameters. The template parameters _b and _d are swapped which would not be possible if you just had one symbol for all such parameters. Furthermore, I've wrapped the fset (corresponding to your defalias) in my version in a let to show that we can use the value of a local variable as fixed parameter in the template. The part of the above source code that solves your problem is just:

(fset #'fix-a-c-in-foo `(lambda (_d _b) (foo ,fix-a _b "c-value" _d)))

Answer 2

apply-partially was most useful back when Emacs did not have lexical binding, since it let you build "closures". But for your example, you don't even need a closure:

(defalias 'fix-a-c-in-foo (lambda (b) (foo "a_value" b "c_value")))

for a more general case, OTOH you do need closures, so you'll want to add -*- lexical-binding:t -*- to the first line of your file and then you can do things like:

(defun whatever (a c)
  (lambda (b) (foo a b c)))

Also, note that (lambda (x y) (foo a x y)) is implemented more efficiently than (apply-partially #'foo a).