Faking local dynamic function bindings

Faking local dynamic function bindings

[Joost Kremers]

Hi all,

I sorta trialed and errored my way to the following code (simplified[1]):

```
(defun foo (sexpr)
  (eval
   `(cl-macrolet ((contains (regexp)
                            `(string-match ,regexp string)))
      (sort (delq nil (mapcar #'(lambda (item)
                                  (let ((string (assq item strings-alist)))
                                    (when ,sexpr)
                                    string))
                              items-alist))
            'string<))))
```

Assume that `items-alist` is an alist with (SYMBOL . STRING) items.

`sexpr` is an interactively built expression that is used to filter
items-alist. It is a single s-expression and is runnable Elisp code,
provided that a macro `contains` is defined. Because I don't want to
define this macro globally (I don't want to have to put a "package"
prefix on it), I tried to define it locally.

That didn't work at first, because the expression `sexpr` is generated
at run-time, which means it cannot be in the lexical scope of
cl-macrolet. So I ended up creating a larger expression containing the
cl-macrolet and eval'ing that.

I have two questions:

- Is there a better ways of doing this? Of course, flet creates dynamic
  function bindings, but it's deprecated. The suggested alternative,
  `(cl-letf (symbol-value 'bar) ...)` doesn't work, because it requires
  that `bar' has a (global) symbol-value, which `contains` in this
  example does not.

- Can't this function be defined as a macro? It seems to me that a
  backquoted expression that is subsequently eval'ed is essentially the
  same as a macro, but my attempts to write foo as a macro have failed.

TIA

Joost




[1] The actual code is here:

https://github.com/joostkremers/ebib/blob/master/ebib.el#L3478



-- 
Joost Kremers                                   joostkremers@fastmail.fm
Selbst in die Unterwelt dringt durch Spalten Licht
EN:SiS(9)

Re: Faking local dynamic function bindings

[Stefan Monnier]

> (defun foo (sexpr)
>   (eval
>    `(cl-macrolet ((contains (regexp)
>                             `(string-match ,regexp string)))
>       (sort (delq nil (mapcar #'(lambda (item)
>                                   (let ((string (assq item strings-alist)))
>                                     (when ,sexpr)
>                                     string))
>                               items-alist))
>             'string<))))

IIUC, sexpr is only known very late (like much later than when you
byte-compile this file).  If that's the case, there's no avoiding `eval'.
But you can move the eval closer to sexpr:

(defun foo (sexpr)
  (sort (delq nil (mapcar #'(lambda (item)
                              (let ((string (assq item strings-alist)))
                                (when (eval
                                        `(cl-macrolet ((contains (regexp)
                                                        `(string-match ,regexp ,string)))
                                           ,sexpr))
                                  string))
                          items-alist))
        #'string<)))

And of course, you don't need `contains' to be a macro:
            
(defun foo (sexpr)
  (sort (delq nil (mapcar #'(lambda (item)
                              (let ((string (assq item strings-alist)))
                                (when (eval
                                        `(cl-flet ((contains (regexp)
                                                     (string-match regexp ,string)))
                                           ,sexpr))
                                  string))
                          items-alist))
        #'string<)))


-- Stefan

Re: Faking local dynamic function bindings

[Joost Kremers]

EN:SiS(9)
Stefan Monnier wrote:
>> (defun foo (sexpr)
>>   (eval
>>    `(cl-macrolet ((contains (regexp)
>>                             `(string-match ,regexp string)))
>>       (sort (delq nil (mapcar #'(lambda (item)
>>                                   (let ((string (assq item strings-alist)))
>>                                     (when ,sexpr)
>>                                     string))
>>                               items-alist))
>>             'string<))))
>
> IIUC, sexpr is only known very late (like much later than when you
> byte-compile this file).

Yes, you understand correctly.

>  If that's the case, there's no avoiding `eval'.

This is the point where I hit myself over the head and say duh... That
should have been obvious, even to me.

> But you can move the eval closer to sexpr:
>
> (defun foo (sexpr)
>   (sort (delq nil (mapcar #'(lambda (item)
>                               (let ((string (assq item strings-alist)))
>                                 (when (eval
>                                         `(cl-macrolet ((contains (regexp)
>                                                         `(string-match ,regexp ,string)))
>                                            ,sexpr))
>                                   string))
>                           items-alist))
>         #'string<)))

This resembles an earlier version of my code, but AFAIU it has the
disadvantage that the local macro binding is created and destroyed every
time the anonymous function is executed, which I guess creates extra
overhead and makes the function slower. That's why I moved the
cl-macrolet outside the mapcar. (Though I haven't done any profiling and
the older version was fast enough not to be annoying...)

> And of course, you don't need `contains' to be a macro:

True, of course. However, I'm using a macro because in the actual code
one of the arguments of `contains` is an unquoted symbol. (That's an
unfortunate design decision I made years ago that has proven to be
completely pointless and impractical. I've been meaning to change it,
but haven't found the time to do so yet.)

Thanks,


Joost

-- 
Joost Kremers                                   joostkremers@fastmail.fm
Selbst in die Unterwelt dringt durch Spalten Licht

Re: Faking local dynamic function bindings

[Stefan Monnier]

> This resembles an earlier version of my code, but AFAIU it has the
> disadvantage that the local macro binding is created and destroyed every
> time the anonymous function is executed, which I guess creates extra
> overhead and makes the function slower.

If that turns out to be a problem, you can do it as follows:

   (defun foo (sexpr)
     (let ((macroenv `((contains
                        . ,(lambda (regexp)
                             `(string-match ,regexp ,string))))))
       (sort
        (delq nil
              (mapcar
               (lambda (item)
                 (let ((string (assq item strings-alist)))
                   (when (eval (macroexpand-all sexpr macroenv))
                     string))
               items-alist)))
        #'string<)))


-- Stefan