See 3.4.1 of the CLHS for details.

HTH,
Edi.

--

Dr. Edmund Weitz
Hamburg
Germany

1> (setq *foo* (list 'a 'b 'c))
(A B C)

2> (setf (nth 1 *foo*) 'd)
D

3> *foo*
(A D C)

4> (setf (elt *foo* 2) 'e)
E

5> *foo*
(A D E)

(defun swap-elt (seq n1 n2)
   (let ((new-seq (copy-seq seq)))
     (setf (elt new-seq n1) (elt seq n2))
     (setf (elt new-seq n2) (elt seq n1))
     new-seq))
swap-elt

(setf x '(1 2 3 4 5))
(1 2 3 4 5)

(swap-elt x 1 2)
(1 3 2 4 5)
x
(1 2 3 4 5)

(swap-elt x 0 4)
(5 2 3 4 1)
x
(1 2 3 4 5)

(setf x "god")
god
(swap-elt x 0 2)
dog

Many ways to skin this cat.

  What are you using to learn to program in Common Lisp now?  I really hope
  you have found a textbook, and are not _only_ using documentation that
  comes with your Common Lisp environment.  Both a tutorial on the language
  and the reference will come in very handy very quickly.  There is no
  nutshell handbook on Common Lisp yet, for instance, because the standard
  (CLHS among friends) is sufficient, but it is not pedagogical in nature.

  www.lisp.org is a good start.

ELT is a generic sequence accessor, and so, takes the appropriate
amount of time for the sequence being acessed. If it is a list, it
takes linear time. If it is an array it takes constant-time. Note that
the Real Python (CMUCL's and SBCL's compiler) has the list-accessors
take linear-time. It's just that Fake Python that has the Fake Lambda
and Fake List where accesses take constant-time, and lists can't share
structure. :)

  Not to spoil your fun here, but either of these will produce the correct
  result with very little overhead:

(merge 'list (list 3) (list 2 4 6 8) #'<)
(sort (list* 3 (list 2 4 6 8) #'<))

  Please note that sort is destructive, so do not use a quoted argument.

| 1)  How can I change all the setf crap to let statements?  I know it's
| bad form to use setf

  setf is not bad form.  It is bad karma to teach that it is.  Your
  professor may return as a Scheme programmer if he keeps this up.  (Or he
  may done something terrible in his previous life and actually be a Scheme
  programmer.)

  It _is_ bad form to setf a component of a quoted constant, however.

|  I can never get the syntax for let working properly...

  It is really quite simple: (let (<binding>*) <declaration>* <form>*).
  A <binding> has the form (<variable> <value>), or just <variable> if you
  plan to set it before you use it.

| 2)  Is there an easy way to sort the list produced by the mapcar?  By
| easy, I don't mean calling (sort timp #'<)  because we aren't allowed to
| use the sorting function.  In fact, we shouldn't even need to sort the
| list... but that's the only way I can get it to work.  Program is a piece
| of cake in Java, C++, C#, etc.... but I don't know lisp well enough to do
| something like a minsort (hence why I asked how to swap elements)  ;)

  I am so strongly opposed to the pointless exercises in re-inventing the
  wheel using idiotic restrictions in order to learn what a wheel is that I
  think teachers who do this to their students should be terminated.

  Having to reimplement basic functionality is not as illuminating as
  reading and understanding a professional programmer's implementation of
  it -- "learn by doing" is good for muscular training.  Programming is a
  process of thinking, so you learn by thinking, not by unthinkingly
  replicating the mere results of other people's thinking.  I also think
  every writer learns to write by reading observantly, taking notes, using
  a very large dictionary to discover nuances and details in meaning, and
  paying attention to details everywhere.  I think this is what studying is
  all about -- learning merely to repeat what others have done before you
  is not study.

| I know I asked for help once already so I understand if people are
| reluctant to provide more aid....

  As long as they keep learning and ask intelligent questions and work on
  your own, it is actually a joy to help people.

  set! is bad form.  setf is not.  Just another one of those differences
  between real Lisps like Common Lisp and toy lisps like Scheme.

btw, i think you want (list* elm x) or (cons elm x)

--

It is a notational gesture.

 (let ((x 3))
   (let ((x (+ x 1)))
     x))

and

 (let ((x 3))
   (setq x (+ x 1))
   x)

do the same thing.  It is purely a notational choice which you use.

  No.  Try some other explanation.

Any language without call/cc looks totally like a toy to me, actually.

But in general, assignments introduce side-effects.  In general, the
following two are *not* equivalent:

(begin
  (set! x 3)
  ...)

(let ((x 3))
  ...)

The latter is side-effect free; the former is not.  Functions which
only include side-effect free forms have values which depend purely on
their arguments; this is not (in general) true if you use set!.

I belabor this only because in the Scheme world, at least, this is
exactly the normal definition of a side-effect.

Right--some uses of set! are side-effect free.  But all uses of let
are always side-effect free.

Surely side effects are often necessary to express a computation
cleanly, but as SICP points out, such cases really occur when you have
things like state-maintaining objects of some sort.

I fully agree that this is an issue of taste, culture, and style.  I
only entered the discussion to point out that people who's style
includes the maxim "avoid unnecessary set! and friends" have a
legitimate and useful style, and that the original poster was probably
coming from that background.

Incidentally, this is not really a Scheme v. Lisp issue.  Side effects
are looked down on by a huge number of older Lisp texts and
implementations and programmers.  Modern Common Lisp looks more like
PL/I to me, so I guess all kinds of weird things are now normal
there.  :)

  The key was the difference between the communities.  Scheme is a toy seen
  from Common Lisp.  This is a Common Lisp forum.  Whatever Scheme freaks
  need to disparage in order to feel good about Perl, no, wait, Scheme, is
  trolling in comp.lang.lisp.  I find it odd that you did not recognize
  that you were trolling to begin with, and only got "insulted" when you
  got a response in kind.  Scheme freaks go nuts about set! and call upon
  various deities to ensure that people who use it do not get a second
  chance, while Kent Pitman has offered us a reasonable distinction between
  intra-scope assignment and extra-scope side-effects.  So Scheme's silly
  knee-jerk reaction to set! is the same as the knee-jerk reaction to goto
  -- failure to understand when it has its uses causes a religious response
  to its presence.  I also wonder why you keep trolling if you think it is
  in any way inappropriate.  Me, I think poking fun at Scheme is one of the
  few available pleasures that nobody could _possibly_ be hurt by, since it
  is such a toy language.  Now, if I posted that in comp.lang.scheme, it
  would be trolling and insulting.  Much like it would have been if I had
  posted any of my acidic comments on that XML failure to comp.text.xml.
  And considering all the venomous crap that Scheme freaks pour over the
  real Lisp, I think we should stay away from Northern Ireland-like ways to
  deal with our feeling "insulted" by what other people say.  Including,
  but not limited to people who now are "insulted" by my reference to the
  bellicose cultures of Northern Ireland.  Trust me, if I had used Israel
  and Palestine as the canonical example of, no, wait, let's not do that.

I would never say something like "never use set!"; I'd say (in accord
with usual Scheme style) "you get clearer Scheme programs if you only
use set! where it's really necessary--which is usually when you are
implementing some kind of state-preserving object".

You seem to have a common pattern here: you post something really
provocative, you accuse someone else of trolling when you were the
first really provocative poster, etc, etc.

It may be the only option for me here is to just skip your posts
entirely, but I'd hate to do that, because amidst the 10% of venom is
90% of very interesting elucidating stuff.

I haven't said any "venomous crap" against "the real Lisp" (which is,
of course, Maclisp) :).  I haven't said anything venomous against that
other PL/I Lisp (you know, Common Lisp).  Actually, the first edition
of Common Lisp was a really nifty achievement, but the later stuff is
baffling to me.  It's an issue of style though, unlike many, I don't
have any particular zealoutry to convince everyone that my way is the
only true way.

  The nature and process of newsgroup splits dictates that if you get a
  forum for yourself, you do _not_ bother the general community.

  comp.lang.scheme decided to make have own community, and they should be
  happy there instead of wanting _two_: One for your own little pet
  language, and for the the general "Lisp" that you refuse to recognize
  that you are no longer a member of by virtue of your own forum.

  The same goes for Dylan, but we have _thankfully_ been relieved of D*lan
  propaganda, lately.

| Well, I wasn't insulted, I just said it seemed like you wanted an
| argument--which seems true indeed.

  I respond to your accusation that I want an insult battle.  Do not use a
  rejection of your position as proof that it was true.  Such dishonesty is
  usually reserved for extreme and ultra-conservative politicians, not
  people who have honest intentions with what they do.

  Some people I have argued against in the past have a very serious problem
  seeing a difference between my arguing against what they argue for and my
  arguing for what they argue against.  I suggest you think this over and
  make sure you know what people are actually arguing for and against.  If
  you have a philosoophy background, this difference should be _really_
  easy to see.

| You seem to have a common pattern here: you post something really
| provocative, you accuse someone else of trolling when you were the first
| really provocative poster, etc, etc.

  Really?  I wrote:

| Ah, so this is an insult battle.  Not interested here.

  Could it _possibly_ be that you were the first to go hostile here, and
  that you are so blind to your own actions that you are _never_ at fault?

  There are a lot of people out there who have deep psychological barriers
  to accepting that they behave badly in some way and who defend themselves
  by accusing the other party of everything that could possibly apply to
  themselves, and who even play the stupid mirror game, but the refusal to
  consider that the other party is at fault is _not_ the moronic argument
  that one is not.  You have to think in such terms to even arrive at the
  idea that that is what other people do.  If you are only used to such
  people, I pity you, but a _little_ room for a balanced view of things
  _should_ be available even in the most prejudiced who really need to
  regard themselves as "good guys" _all_ the time.

  The biggest, if not the _only_, problem on USENET is that people need to
  defend themselves, usually because someone thinks that they defend
  themselves best by accusing somebody of something completely outlandish
  that they never expressed, implied, or opened up to be inferred.

| I haven't said any "venomous crap" against "the real Lisp" (which is, of
| course, Maclisp) :).  I haven't said anything venomous against that other
| PL/I Lisp (you know, Common Lisp).

  Why is _this_ not "really provocative"?  You are in a forum where people
  are interested in Common Lisp in particular, yet you go on and on with
  your stupid insults towards Common Lisp, but as soon as I have a little
  fun with your toy lanauge, you find it "really provocative" and go nuts?
  Are you for real?

| Actually, the first edition of Common Lisp was a really nifty
| achievement, but the later stuff is baffling to me.  It's an issue of
| style though, unlike many, I don't have any particular zealoutry to
| convince everyone that my way is the only true way.

  "Actually" is usually reserved for facts, not biased opinions.

  Regardless of what you _feel_, it is probably smart to avoid provoking
  people in the forum where people expressly congegrate to enjoy what you
  do not.  This is why I poke fun at Scheme and XML and Perl and C++ _here_
  -- not in their newsgroups.  Do you grasp this difference?  Can you
  _quit_ being so sensitive about your stupid toy language when you are not
  in _its_ particular forum and community?  Of _course_ people have a right
  to think Scheme sucks here -- you guys got your own newsgroup so you
  could discuss Scheme without fighting with real Lispers.

Or, conversely, that if the groups comp.lang.lisp.scheme and
comp.lang.lisp.dylan had been proposed and passed, that discussion of
those would then be welcome here?

We need a design pattern for this, and I have to credit Woodward &
Bernstein for the original "non-denial denial". But it seems the NG
equivalent arrow goes the other way, we've had a continuing
con-continuation and an interested lack of interest.

Needless to say, I'm not going to say anything about this.

--

The first post to comp.lang.lisp was in November of 1986; _Common
Lisp, The Language_ was published in 1984.

And is dated 1982-03-27 23:56:29 PST.

It's by John Foderaro.  The first sentence is:

"The net.lang.lisp newsgroup is for the discussion of any and all lisp
dialects."

(defun insert-n-sort (p elm lis)
     (mapcar #'(lambda (x)
                 (when (funcall p elm x)
                     (setf...
;
; the spec said LIS was already sorted (I am guessing by P) so
; there is no need for a SETF, you just have to return whatever you whip
up to
; insert elm in the list, using RETURN-FROM insert-n-sort
;
(defun insert-n-sort (p elm lis)
     (mapcar #'(lambda (x)
                 (when (funcall p elm x)
                     (return-from insert-n-sort
                       (append
                        (append
;
; no big deal, but append takes multiple (&rest) args, so one will do:
;
(defun insert-n-sort (p elm lis)
     (mapcar #'(lambda (x)
                 (when (funcall p elm x)
                     (return-from insert-n-sort
                       (append
                        (subseq lis 0 (position x lis))
                        (list elm)
;
; no big deal again, but you may as well just say (cons elm <the
rest>)...
; not sure even which is clearer. anyway, i'd save a cons cell and code
up...
;
(defun insert-n-sort (p elm lis)
  (mapcar #'(lambda (x)
              (when (funcall p elm x)
                (return-from insert-n-sort
                  (append
                   (subseq lis 0 (position x lis))
                   (cons elm (subseq lis (position x lis)
                                     (length lis)))))))
    lis))
;
; we are forced into the needless effort of position and subseq calls
because mapcar
; hands just the car of a cons cell to the mapping function, so when you
find the
; insertion point you do not know where you are. maplist passes each
cons
; cell to the mapping function
;
(defun insert-n-sort (p elm lis)
  (maplist #'(lambda (lis-remaining)
              (when (funcall p elm (car lis-remaining))
                ;
                ; the bad news is we only know what comes after (not
before) the insertion point,
                ; but if we understand cons cells (the point of this
exercise?) we
                ; can splice in place:
                ;
                (setf (cdr lis-remaining)
                  (cons (car lis-remaining) (cdr lis-remaining)))
                (setf (car lis-remaining) elm)
                ;
                ; we be jammin
                ;
                (return-from insert-n-sort lis)))
           lis)
  ;
  ; predicate was never satisfied if we get here, so elm "loses" and
goes to end
  ;
  (nconc lis (list elm)))

Two things: the above is destructive; it changes the list received.
So does SORT, so maybe that is OK.

Second, if the point of this was for you to master cons cells (which I
suspect since you were
told not to use SORT) then forget you ever saw the splicing bit and try
to work
it out for yourself. I recommend drawing pictures of cons cells at first
to make this much
easier.

--
Qui beneficium dedit, taceat; narret qui accepit                 -- Seneca