Darren Teemull wrote:
> 
> Thanks for all the suggestions from the people who responded to my
> earlier questions. This is what I finally came up with (Sorry, but I
> don't think it matches anyone's suggestion, but that's simply because of
> my ineptness at Lisp) feel free to rip it apart and improve on it if you
> like.
> 
> Solution to the flattening and combining of two lists, each containing
> any amount of nested lists and brackets (eg. 1=((a b) c) & 2=(d ((e) f))
> then (flatten 1 2) = (a b c d e f)) :
> 
> (defun flatten (fl1 fl2)
>     (cond ((null fl2) NIL)
>               (t (cond ((null fl1) (flatten fl2 (cdr fl2)))
>                            ((listp (car fl1))
>                                (cons (car (flatten (car fl1) fl2))
>                                (if (null (cdr (car fl1)))
>                                    (flatten (cdr fl1) fl2)
>                                    (flatten (cons (cdr (car fl1)) (cdr
> fl1)) fl2))))
>                            (t (cons (car fl1) (flatten (cdr fl1)
> fl2)))))))


There are some typical beginner's problems here: odd indentation,
unnecessary cond calls (why not take "(t (cond" away from the third
line?), and some odd behaviour: try (flatten '(some list) nil), what was
the intended result?

But the main problem here is architectural: you get unnecessary
complication trying to do 2 things (flattening and combining lists) at
the same time; especially as the case of 2 lists is rather arbitrary. It
would be simpler to write a separate function to flatten one list, and
another function to combine them.

for example:

(defun flatten (list)
  "Flattens a list: (a b (c d (e)) f) -> (a b c d e f)"
  ;; Write something here to do the job...
  )

(defun flatten2 (a b)
  "Flattens 2 lists and combines them"
  (append (flatten a) (flatten b)))

(defun flatten-n (&rest lists)
  "Combines its arguments to one list and flattens it"
  (mapcan #'flatten lists))


One of the common errors both beginning students and professors only
dabbling in lisp make is trying to restrict themselves to some arbitrary
"pure" subset of lisp, thereby re-inventing the wheel again and again.

If the idea is to learn using CL productively, you should utilize
whatever machinery exists in the language and leave the low-level
implementation to the implementors. One of the major strengths of CL is
the large "library" of useful stuff already defined in the language.

Re-building existing stuff makes very little sense after the principles
have been learned.

-- 
________________________________________________________________
    ^.          Martti Halminen
   / \`.        Design Power Europe Oy
  /   \ `.      Tekniikantie 12, FIN-02150 Espoo, Finland
 /\`.  \ |      Tel:+358 9 4354 2306, Fax:+358 9 455 8575
/__\|___\|      <dpe.fi at Mailto:Martti.Halminen>   http://www.dpe.fi