I'm trying to read a list ("c:/input.txt") and storing it within
'myList' by using this piece of code:

-----------------//------------
(setf myList '())
(with-open-file (f "c:/input.txt" :direction :input)
  (loop for line = (read-line f nil nil)
     while line
       do (
         (setf myList(append myList line)
       );end-do
     );end-while  
   );end-loop
 );end-with
-------------------//-------------

But I get this error:

------------------//---------------
LISP error:
(SETF TEST::MYLIST (APPEND TEST::MYLIST LINE)) is invalid as a
function
-----------------//---------------

(setf myList '())
(with-open-file (f "c:/input.txt" :direction :input)
  (loop for line = (read-line f nil nil)
        while line
          do ((setf myList (append myList line)))))

So, I hope that it's obvious now that you have the syntax of the `do'
clause wrong -- you are trying to call the function
(setf my-list ...), as

Apart from this, you may want to use
(defvar *my-list* '())
rather than
(setf myList '()), as the setf of a variable that hasn't been
def[var|parameter]ed at top-level is undefined;

alternatively you might wish to do
(with-open-file (f ...)
  (loop for line = (read-line f nil nil)
        with my-list = '()
        while line
          collect line into my-list
        finally
          return my-list))

and use the return value.

Hope that helps,

  Well, get rid of the terribly confusing ;end-crap first (the comments do
  not even match what they say they match), and try to see how other people
  write their Common Lisp code.  If you do things differently from more
  experienced people, you do _not_ know better because you are new at this.
  That attitude may be at the core of your problem, actually, since you
  have not paid attention to how parentheses "work" in Common Lisp.  From
  your indentation style alone, it appears that you think they have a very
  different function than what they actually have.

  When you have figured out the invalid function error, retrace your steps
  and figure out where you got the terrible idea to use append, then do the
  same for that global variable.

  Otherwise, you have it mostly right.

| But I get this error:
|
| ------------------//---------------
| LISP error:
| (SETF TEST::MYLIST (APPEND TEST::MYLIST LINE)) is invalid as a
| function
| -----------------//---------------
|
| Any suggestion? Than you very much

  The error message is actually very precise.  Try to evaluate ((+ 1 1))
  and see what it says.  Compare with (+ 1 1).  Also count the number of
  parentheses you use in your code carefully.  Get an editor that helps you
  keep track of them and takes care of that indentention stuff for you, too.

1. Almost half the lines in your program are comments which tell you
nothing that the editor will not immediately tell you too, except it
will not get it wrong if you change the program, whereas yhour
comments will likely rapidly become incorrect (in fact, they are
already incorrect).  Concentrate on comments that tell you things that
you or the editor can't immediately work out from the code.

(with-open-file (f "c:/input.txt" :direction :input)
  ;; third arg NIL means no error on EOF
  ;; fourth NIL means return NIL in that case.
  (loop for line = (read-line f nil nil)
        while line
        do (
            (setf myList (append myList line)))))

2. You have misunderstood the syntax of LOOP: all the forms following
DO until another LOOP keyword are evaluated, not a single list of
forms.

(with-open-file (f "c:/input.txt" :direction :input)
  ;; third arg NIL means no error on EOF
  ;; fourth NIL means return NIL in that case.
  (loop for line = (read-line f nil nil)
        while line
        do (setf myList (append myList line))))

3. Your algorithm is quadratic in file length, since APPEND is linear
in list length.  Obsessives will also worry that APPEND repeatedly
copies the list, but
that is a small problem.  Either build the list backwards and reverse
it, resulting in a linear algorithm, or use one of the
building-a-list-forwards tricks either via one of the COLLECT-style
macros or using LOOP's COLLECT clause:

(with-open-file (f "c:/input.txt" :direction :input)
  ;; third arg NIL means no error on EOF
  ;; fourth NIL means return NIL in that case.
  (loop for line = (read-line f nil nil)
        while line collect line into lines
        finally (setf mylist lines)))

4. The whole (SETF ...) then read the file and assign is really
horrible.  If this is not extracted from a function it's also
technically ill-defined.  If you want to define a top-level variable
do this:

(defparameter *my-lines*
              (with-open-file (f "c:/input.txt" :direction :input)
                ;; third arg NIL means no error on EOF
                ;; fourth NIL means return NIL in that case.
                (loop for line = (read-line f nil nil)
                      while line collect line)))

If you want to write a function that returns the lines in the file do
this:

(defun read-lines-from-file (file)
  ;; Return a list of all the lines in FILE.  FILE is either a string
or
  ;; a pathname
  (with-open-file (in file :direction ':input)
    ;; no real line can be NIL, so we don't need to worry about
    ;; inventing a unique return value here
    (loop for line = (read-line in nil nil)
          while line collect line)))

(defparameter *my-lines* (read-lines-from-file "c:/input.txt"))

Note that this program is the same length in lines as yours, but
includes four lines of comments which are actually useful: two of them
describe the function, and two describe why the READ-LINE works OK
(when, say, READ would need more care), one blank line for
readability, and defines a function which can be used elsewhere.  And
it works (unless I made a typo, it is untested code), and is
efficient.

--tim

Note for CLL people: I think this is a great use of LOOP.  It's *so*
easy to see what is happening here:

   loop for line = <get next line from file, NIL on EOF>
        while line collect line