Emacs Lisp coding style question

[Thorsten Jolitz]

Hi List, 

sometimes I wondered about the following coding style question, so I
decided to do it in public:

Often functions do a lot of work to gather some data and then do a
rather simple action with the gathered data:

#+begin_src emacs-lisp
  (defun foo ()
    (let* ((x (create-x))
          (y (create-y))
          (z (create-z x y))
          (u (create-u z))
          (v (create-v))
          (w (create-w u v)))
      (simple-action w)))
#+end_src

Thats the way I would do it, and I find it easy to write, read and
understand. 

But (without being able to give concrete examples right now) I noticed
that advanced Lispers tend to call this 'C-style', consider the let
bindings unnessesary since the local vars are only used once, and
prefer this style:

#+begin_src emacs-lisp
  (defun foo ()
    (simple-action
     (create-w
      (create-u
       (create-z (create-x) (create-y)))
      (create-v))))
#+end_src

This looks more 'lispy' and might have a slight performance
advantage. But when the 'create-xyz' expressions grow in size the
whole thing might start to look very complicated and it becomes hard to
recognize that its just about `simple-action' with some gathered
data. 

What would be the recommended style for Emacs Lisp, or is this just a
matter of taste?

-- 
cheers,
Thorsten