Spent several hours today trying to figure out why my #elisp code was misbehaving. Turns out, I made a mistake while trying to be clever. Instead of doing:

(when (and cond1 cond2)
  stuff
  ...)

(and cond1 cond2
  stuff
  ...)

I should stop trying to be clever.

#emacs

Edit: when, not while

Okay, I need to do a hacky #elisp thing. Yes, I know it's terrible.

Basically, I have an existing defun. Let's call it foo. I need to replace it with a new function that calls the old one and transforms its output before returning it.

I naïvely assumed I could do it like this:

(let ((oldfunc (function foo)))
  (defun foo ()
    (my-transform (funcall oldfunc))))

I'm sure there's a way to do this.
#AskFedi

Edit: Got it. It's:

(let ((oldfunc (symbol-function 'foo)))
  (defun foo ()
    (my-transform (funcall oldfunc))))

Also, there's still something Gmail isn't liking. Looking at the differences in the headers between emacs and my other clients (whose mail does get through), the next most obvious difference is that the Content-Type header doesn't specify an encoding. Whether this is the actual problem or not, I should probably fix that. I'm just working on how.

Carlo Zancanaro

2026-04-12 02:26:37

The usual way to do this would be to "advise" the function with an "around" advice. gnu.org/software/emacs/manual/…

gnu.org

Advising Functions (GNU Emacs Lisp Reference Manual)

^www.gnu.org

I'm certain I have reinvented a wheel here, but for the life of me I can't find it. Have I?

(defmacro jrl-extract-list (vars list &rest body)
  "Split a list into indiviual variables"
  (let ((list* (gensym)))
    (append
     `(let ,(cons (list list* list) vars))
     (seq-map (lambda (var)
                `(setq ,var (car ,list*)
                       ,list* (cdr ,list*)))
              vars)
     body)))

Edit: Of course it was pcase.

I just put a call to eval in my code and I feel dirty now.

The context went something like this:

(eval (cons 'concat (my-function arg1 arg2)))

(concat . (my-function arg1 arg2))

(concat my-function arg1 arg2)

Is there a better way I could've written this?
#emacs #lisp #elisp

Edit: Got my answer. I wanted:

(apply 'concat (my-func arg1 arg2))

Edit 2:
It turns out the code I really wanted was:

(string-join arg2 arg1)

Edit 3:
Here's the actual code:

(defun lambdamoo-run-text-replacements (str)
  "Perform text replacements on the string"
  (dolist (vals lambdamoo-text-replacements)
    (let* ((from (car vals))
           (to (cdr vals))
           (split (split-string str from)))
      (setq str (string-join split to))))
  str)

(catch :abort
  ;; do something
  (when condition
    (message "A bad thing happened")
    (throw :abort nil))
  ;; do something else
  )

(progn
  ;; do something
  (when condition
    (user-error "A bad thing happened"))
  ;; do something else
  )

#Elisp logic:

All interned symbols can be found in a lookup table. This table is bound to the obarray symbol.

Hang on a minute...

I can only assume that the underlying C code has its own pointer to this table and the obarray symbol is only provided as a convenience for elisp functions that can't see this pointer?
#emacs #lisp

I am dangerously close to unleashing my first #emacs package on the public. It's nothing fancy and still relatively niche, but I deem it potentially useful enough to be worth publishing.

There are a couple small features I want to add and a few things that still need some polish, but it's almost ready for a version 0.1 release.

It's not anything ground breaking or anything. I'm still pretty much an #elisp novice, but I'm proud of it anyway.

More details when it's released.

I've been playing around with keymaps. Apparently they can be used to create menus that give the user a visual list of options. The canonical way to make them is aparently with make-sparse-keymap to create the menu and define-key to add options to it, but this causes some confusing behaviour.

Take the following example:

(let ((menu (make-sparse-keymap "My menu")))
  (define-key menu "a"
    '(menu-item "Foo" foo))
  (define-key menu "b"
    '(menu-item "Bar" bar))
  menu)

(keymap (98 menu-item "Bar" bar) (97 menu-item "Foo" foo) "My menu")

Now, I understand that the nature of lists in lisp make inserting an element at the top of the list less computationally expensive, but when you've already got to walk the whole list anyway to ensure the key binding isn't already present, this no longer feels like an adequate excuse.

Am I missing something?

#emacs #elisp