But in general, using symbols to name things is the (Common) Lisp way,
  and using the values directly is the Scheme way.

and the context can be found at
http://groups.google.com/groups?selm=3227419925997748%40naggum.net&ou...

I'm sorry, but I really don't see how citing that can be considered a
provokation.  Perhaps you would be so kind as to explain it to me?

These are very basic questions, (the kind of problem that one
encounters in the first week of an introductory course) so you should
be able to find the answers yourself by reading the HyperSpec - Kent
even gave you an additional hint, and suggested that you should take a
look at mapcar.

Please don't take offense, but we get a lot of students here
essentially asking correspondents to c.l.l to do their homework for
them. Yours are such elementary questions, that they look like a first
week homework set. If you're not asking for help with homework, but
are merely a newcomer to Common Lisp, then your should *really*
familiarize yourself with the HyperSpec - a document which is one of
the best references for any subject anywhere - the Common Lisp
community is *extremely* fortunate to have it.

You are absolutely right about what you said. this is the first time I use
newsgroups for such things...
Thanks for replying to me. and here are the questions in a clear way and
what I did so far:

i wanted to construct a function that will sort this list:

(b (c (d (e f)) ) g h k)

i was able to write the function to sort a list like this but that has
integers and not characters.

(defun print_list(L)
(cond
((NULL L) nil)
((atom L) (list L))
(t (append   (print_list (car list1)) (print_list (cdr list1)) ) )
))

I was able to get all the values of the list in one list (b c d e f g h k)

then I wanna pass this list to char-code to have all the values changed to
their ASCII code.

I used this function that I wrote
(sort (mapcar #'char-code '(#\t #\y)) #'>)

but the problem is I wanna feed the characters in the list to char-code and
not characters that I hardcoded (ex. (#\t #\y in the above example)

Hope I am clear this time:)

Sherif

"Kent M Pitman" <pit...@world.std.com> wrote in message
news:sfw7knajnd2.fsf@shell01.TheWorld.com...

  So there is no hope for a less hostile, more intelligent Erann Gat who
  actually manages to focus on the technical, and we can only expect more
  disillusioned whining and destructive rhetoric and context-free quoting
  and idiotic attacks that only tell us you refuse to grow a clue.  OK.

///
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

(defun flatten (tree)
  (cond ((null tree) nil)
        ((atom tree) (list tree))
        (t (append (flatten (car tree))
                   (flatten (cdr tree))))))

FLATTEN is the common name for this kind of function.  Call it
whatever you want, but print_list is a bad name for two reasons:
First, it doesn't print anything but returns a list; second, we
usually use hyphens instead of underscores.  And consider using
NCONC instead of APPEND.

BLARK 12 > (flatten '(b (c (d (e f))) g h k))
(B C D E F G H K)

you have a list of /symbols/, not characters.  And it is already
sorted, BTW.  Note that the function STRING< works well for
symbols, too.  If you really want to work with characters, you
should do something like

BLARK 17 > (flatten '(#\b (#\c (#\d (#\e #\f))) #\g #\h #\k))
(#\b #\c #\d #\e #\f #\g #\h #\k)

And if you want to sort such a thing, you might either use CHAR<
or CHAR-LESSP, or, if you insist on bringing CHAR-CODE into the
game, lookup the :KEY argument for SORT.

Regards,
--
Nils Goesche
Ask not for whom the <CONTROL-G> tolls.

Regards,
--
Nils Goesche
Ask not for whom the <CONTROL-G> tolls.

--

Dr. Edmund Weitz
Hamburg
Germany

  There is no "builtin" function called "flatten".  Please do not post your
  beliefs as though they were facts when you can so easily check them.

| you might want to take a look at other sorting functions, for
| example those for strings ...

  Maybe you mean comparison functions rather than sorting functions?

| I have the feeling that you need to unlearn some old habits to be able to
| write idiomatic lisp programs.

  Maybe you should delay your advice for a while.

///
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

(#\B (#\C (#\D (#\E #\F))) #\G #\H #\K)

(defun characterify-tree (tree &optional acc)
  (cond ((null tree)
         acc)
        ((consp (car tree))
         (characterify-tree (cdr tree)
                            (append acc (list (characterify-tree (car tree) nil)))))
        (t
         (characterify-tree (cdr tree)
                            (append acc (list (character (car tree))))))))

Or, using more contemporary Common Lisp functionality, like this:

(defun characterify-tree (tree)
  (loop for elt in tree
        collect (if (consp elt) (characterify-tree elt) (character elt))))

Either way, you should get results like this:

(characterify-tree '(a b (c d (e f) g) h))
=> (#\A #\B (#\C #\D (#\E #\F) #\G) #\H)

http://groups.google.com/groups?selm=gat-1204021042320001%40192.168.1...

        (Erann Gat writes:)
        Well, according to Erik, it marks me as doing things the "Scheme way".  Of
        course, Erik, also distinguishes between "Scheme is a Lisp" and "Scheme is
        a member of the Lisp family of languages", so maybe "writing Scheme in CL"
        and "doing things the Scheme way [in CL]" don't mean the same thing
        either.

When you're talking about something that you do,
believe or think (or whatever) why do you need to
bring someone else opinion about it?.

This is a technical forum. It goes like this:
        1 You ask a question
        2 Get an answer (if lucky)
        3 You study the answer assuming it's right
        4 Ask for clarification if needed
        5 Repeat

Don't need to imagine or talk or whine about other
people opinion or thinking.

--

Why is this not working??

(defun print_list(L)
(cond
((null L) nil)
((atom L) (list L))
(t (append   (print_list (car L)) (print_list (cdr L)))
(stable-sort (L) #'char-lessp))

I am trying to >(print_list '(#\f (#\h (#\b (#\e #\d)) ) #\g #\c #\k))

to get a sorted list (b c d e f g h k)

What is missing here?? please help!!!

If I wanted to use prog() here what do I need to do......

Appreciate all the help.

(defun print_list(L)
(progn()
(cond
((null L) nil)
((atom L) (list L))
(t (append   (print_list (car L)) (print_list (cdr L)))))
(stable-sort L #'char-lessp)))

All I want now is to make the stable-sort function use the list output by
the (con..... statement and not the original list.  I think that is all I
need, right???

Anyway, fix that and you are left with a common mistake: append makes a
new list which you do not capture anywhere, it just drifts off into a
GC. then you sort good old L, which is unchanged and hence still has
depth, ie, members which are not chars. char-lessp don't play dat.

throw in (setf L ....) around that append and i think you'll be ok.

--

  Q.E.D.

  Just take charge of your own life, now.  Think for yourself.  Here is a
  book suggestion for you: ISBN 0-312-28118-8.  Think about yourself,
  _only_, when you read it.  And _please_ figure out this context thing.

///
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

  The underscore is quite young.  The character in that position in ASCII and
  its precursors has a long history, but generally, _ was a back-arrow and
  ^ was an up-arrow.  _ has come to replace blank, which many have rendered
  as an underscore with very short vertical bars on each side.  Primitive
  syntax descriptions have a serious problem with whitespace, so they claim
  that a-b is three tokens, a_b one.  This arbitrariness is frustrating to
  people who know better.  OfCoursePeopleWhoWriteLikeThisDoNotSeeTheProblem.

| Or is this just an attempt to make the C programmers taking the class
| feel better?

  It is probably a feebleminded attempt to learn real syntaxes in stages,
  slow adaptability or something.  I mean, no textbooks on Lisp or Scheme
  or any other sufficiently similar language uses _ in identifiers, so this
  is an independent creation of the student who is unable to observe what
  others are doing.  Generally, I consider poor indentation and _ in symbol
  names a clear sign that the requestor is more lost that I would consider
  it in my interest to try to rectify.

  But more generally, space should be a valid character in identifiers, and
  with ISO 8859 and Unicode, it can be: just use the non-breaking-space.  I
  think this really _rules_ for extra super-high readability.

///
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

"Symbolic programming" is a rather broad term which is generally used
to contrast with "numeric programming".

And the fact that you should use a better editor (since your
indentation is "less-than-optimal").

Have you understood the difference between symbols and characters?

Here is the solution BTW.  Hope it will help you homework.

Given your last post, I will assume that your input list L is a nested
list of characters.

(defun sort-the-homework-list (L)
  (sort (flatten L) #'char<=))

Now.  If you want you can also check L

(defun sort-the-homework-list-2 (L)
  (let ((flattened-list (flatten L)))
    (unless (every #'characterp flattened-list)
      (error "Some element in the list (~S) is not a character."
             (find-if (complement #'characterp) flattened-list)))
    (sort flattened-list #'char<)))

Does this help?  Note that this is a good answer.  If your instructor
wnats something different it is his problem.

Cheers