Some improvements for cl-flet

[akater]

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?

signature.asc
Description: PGP signature