Re: the (declare special) declaration with lexical scope.

[Platon Pronko <platon7pronko@gmail.com>]

I'm not qualified to answer the question about lexical scope.

However I'm interested why you didn't consider to make the entire mustache function
into a macro that expands to concat call with variables already interpolated?
This way it will work regardless of lexical or dynamic binding.

I suppose this might break if template is dynamically generated somewhere,
however templates are usually static and thus can be embedded at compile time
(it will be the fastest-performing option, aside from other benefits).

Here's an example of what I mean:

(defun mustache-build (template)
   (let ((pattern-start (string-match "{{\\(.*?\\)}}" template)))
     (if (not pattern-start)
         template
       `(,(substring template 0 pattern-start)
         (prin1-to-string ,(intern (match-string 1 template)))
         ,@(if (>= (match-end 0) (length template)) nil (mustache-build (substring template (match-end 0))))))))
(defmacro mustache (template)
   `(concat ,@(mustache-build template)))

(macroexpand '(mustache "a={{a}} b={{b}}"))
; (concat "a=" (prin1-to-string a) " b=" (prin1-to-string b))

(let ((a 42) (b '(+ 2 3)))
   (mustache "a={{a}} b={{b}}"))
; "a=42 b=(+ 2 3)"

--
Best regards,
Platon Pronko
PGP 2A62D77A7A2CB94E