I've implemented some fixes for ~cl-flet~ necessary to address an issue with ~cl-generic~ but also improving ~cl-flet~ proper. Before I post the patch, I'd like to clarify one issue. ~cl-flet~'s ~(func exp)~ syntax, as described and implemented, is incompatible with ~flet~ syntax as specified in Common Lisp. Namely, ~(func exp)~ syntax does not allow to distinguish between a form ~exp~ returning a function and an arglist ~exp~ for a function ~func~ that always returns ~nil~. Consider the following valid (but stylistically poor) Common Lisp code: #+begin_src lisp :wrap example lisp (flet ((f #'g)) (f t t)) #+end_src #+RESULTS: #+begin_example lisp NIL #+end_example If I understand the purpose of ~cl-lib~ correctly, corresponding ~cl-flet~ form should return ~nil~ as well. However, it errors: #+begin_src emacs-lisp :results code :wrap example emacs-lisp (condition-case err (cl-flet ((f #'g)) (f t t)) (t err)) #+end_src #+RESULTS: #+begin_example emacs-lisp (void-function g) #+end_example In case it's not clear what's going on: the previous example is equivalent to the following one, only with ~function~, ~g~ replaced with ~x~, ~y~ correspondingly: #+begin_src lisp :wrap example lisp (flet ((f (x y))) (f t t)) #+end_src #+RESULTS: #+begin_example lisp NIL #+end_example but due to ~(func exp)~ syntax, ~(x y)~ is presumed to be a form meant to return a function, rather than an arglist, and so #+begin_src emacs-lisp :results code :wrap example emacs-lisp (condition-case err (cl-flet ((f (x y))) (f t t)) (t err)) #+end_src #+RESULTS: #+begin_example emacs-lisp (void-function x) #+end_example The syntax of ~flet~ could only be compatible with ~cl-flet~'s ~(func exp)~ syntax when ~exp~ is presumed to be a non-list. For example, ~exp~ could be a symbol. The following expression could also be unambiguously interpreted in style of ~(func exp)~ because ~nil~ is not a valid function argument: #+begin_src emacs-lisp :results code :wrap example emacs-lisp (cl-flet ((f (lambda nil nil))) (f)) #+end_src #+RESULTS: #+begin_example emacs-lisp nil #+end_example However I don't think it's worth it to use complicated rules to distinguish such cases. ~flet~ just has its own syntax, incompatible with the (Scheme-inspired, likely) idea of binding a function to a variable. Such complications would keep ~cl-flet~ unfit for use in macroexpanded (and otherwise generated) code. Last but not least, ~(flet ((f (lambda nil nil))) (f))~, etc., is not a valid Common Lisp code. Note also that the following is valid (and stylistically fine) Common Lisp code: #+begin_src lisp :wrap example lisp (flet ((f ())) (f)) #+end_src #+RESULTS: #+begin_example lisp NIL #+end_example However, evaluating corresponding ~cl-flet~ form errors: #+begin_src emacs-lisp :results code :wrap example emacs-lisp (condition-case err (cl-flet ((f ())) (f)) (t err)) #+end_src #+RESULTS: #+begin_example emacs-lisp (void-function nil) #+end_example Finally, note that (an equivalent) ~(func exp)~ syntax could not be adopted by at all by ~cl-macrolet~, as macrolet forms support destructuring lambda lists. For example, the following is a valid (but stylistically poor) Common Lisp code: #+begin_src lisp :wrap example lisp (macrolet ((f (lambda () 'x))) (f t nil (t t))) #+end_src #+RESULTS: #+begin_example lisp NIL #+end_example Given all this, I think ~(func exp)~ should be dropped from ~cl-flet~. My patch (already discussed with Stefan Monnier to some extent) introduces function ~cl--expand-flet~ which retains the functionality currently provided by ~(func exp)~, in an unambiguous way. I suggest to move it there, away from ~cl-flet~. Do you agree?