(setf a (make-string 100))
(blah a #\b)
(blah a #\b)
(blah a #\c)

and then have a contain the string "bbc"

I can see how to do it with CONCATENATE but then I end up with

(setf a (make-string 100))
(setf a (concatenate 'string a (make-string 1 :initial-element #\b)))
(setf a (concatenate 'string a (make-string 1 :initial-element #\b)))
(setf a (concatenate 'string a (make-string 1 :initial-element #\c)))

but this just seems too hideous.  I also see how one could do it with aref

(setf a (make-string 100))
(setf (aref a 1) #\b)
(setf (aref a 2) #\b)
(setf (aref a 3) #\c)

but I would like not to have to keep track of indices and I'd like not to
worry about that 101st element.

Thanks ever so much.  It's been a long time and I didn't work with strings
last time I worked with lisp.

cheers

bruce

(setf a (make-array 100 :type 'character :fill-pointer 0))
(vector-push a #\b)
(vector-push a #\b)
(vector-push a #\c)

If you want it to be able to grow past 100 characters, use :extendable t
when making the array, and use vector-push-extend instead.

    (setf (concatenate 'string a (string #\a)))
    (setf (concatenate 'string a (string #\b)))
    (setf (concatenate 'string a (string #\c)))

You could also do

    (setf a (format nil "~Aa" a))
    ...and so on

(But if you want a dynamically resizable sequence of letters, why not
use a list, and then coerce it into a string when you need to print it?)

   (concatenate 'string '(#\a #\b #c)) ==> "abc"

But I have a different question:  How to "coerce" a list of symbols to
append them into a string:

   (setf aa '(a bc de f))
   (list-of-symbols-to-string aa)  ==> "abcdef"

This is how I did it:
   (defun list-of-symbols-to-string (list)
      (apply #'concat-strings (mapcar #'string list)))

   (defun concat-strings (&rest r)
      (eval (append '(concatenate 'string ) r)))

But I really wanted to do without the eval, rather something like:
   (defun concat-strings (&rest r)
      (concatenate 'string @r))

Thanks,
John

  By not getting into this fix to begin with.  (Why are they symbols?)

|    (setf aa '(a bc de f))
|    (list-of-symbols-to-string aa)  ==> "abcdef"
|
| This is how I did it:
|    (defun list-of-symbols-to-string (list)
|       (apply #'concat-strings (mapcar #'string list)))
|
|    (defun concat-strings (&rest r)
|       (eval (append '(concatenate 'string ) r)))
|
| But I really wanted to do without the eval, rather something like:
|    (defun concat-strings (&rest r)
|       (concatenate 'string @r))

(apply #'concatenate 'string (mapcar #'string list))

  If you have a Scheme background (where apply takes two arguments),
  you could have consed 'string onto the list of arguments, too.

(setf a (concatenate 'string a (string #\a)))

Also one does not concatenate the string to a variable.
You are concatenating the value of A (-> a string) and the
value of (STRING #\a) (-> also a string) to a new (!!) string.

Common Lisp also has the idea of adjustable array (which
can change the size) and arrays with a fill-pointer.
Adding elements to an array with a FILL-POINTER
is done via VECTOR-PUSH. If you want to use the feature
of an adjustable array, VECTOR-PUSH-EXTEND is your
friend:

? (setf a (make-array 10
                      :element-type 'character
                      :adjustable t
                      :fill-pointer 0))
""

? (vector-push-extend #\a a)
0

? a
"a"

? (vector-push-extend #\b a)
1

? a
"ab"
? (vector-push-extend #\c a)
2

? a
"abc"

Another way cons up strings is to use a special stream:

(with-output-to-string (stream)
  (princ #\a stream)
  (princ #\b stream)
  (princ #\c stream))

or

(with-output-to-string (*standard-output*)
  (princ #\a)
  (princ #\b)
  (princ #\c))

(defun list-of-whatever-to-string (list)
  (format nil "~{~A~}" list)
  )

Hmmm.  By an amazing coincidence the body of the function happens to be
the same length as its name.

Note:  Depending on how you want the output to appear in the case of
mixed case symbol names, different packages, etc. you might want to use
~S instead of ~A.

Erik, just as Lisp has evolved beyond the outdated concepts of
"interpreter/slow/etc." and Common Lisp has evolved beyond CLtL1,
Scheme too has made *some* progress over its life, and in fact has
had multi-arg "apply" since at least 1986 with the release of R3RS.

Granted, in R3RS and R4RS the two-arg form was called an "essential
procedure" and the multi-arg form was just a "procedure", but by the
time of the IEEE Scheme Standard in 1991 (and in R5RS today), this
distinction had vanished:

        (apply proc arg1 ... args)

        Proc must be a procedure and args must be a list. Calls proc
        with the elements of the list (append (list arg1 ...) args)
        as the actual arguments.

For example:

        > (apply vector 1 2 3 '(4 5 6))
        #(1 2 3 4 5 6)
        > (apply string-append (map string '(#\a #\c #\e) '(#\b #\d #\f)))
        "abcdef"
        >

-Rob

cheers

bruce

  What?  You mean it's time for _me_ to evolve, too?  I thought I
  could avoid that, but if my .project ("immortality in our lifetime")
  has any hopes, I'd better get used to it.

  Seriously, though, I have always disliked the separation between
  essential and non-essential procedueres in Scheme, so if it has
  vanished as a whole, I'm as delighted as I can be when I don't like
  Scheme to begin with.  If it is only gone for apply, well, it's a
  step in the right direction.

  Thanks for the update.

Cheers

Erik Naggum  <e...@naggum.net> wrote:
+---------------
| * Rob Warnock
| | Scheme... has had had multi-arg "apply" since at least 1986... R3RS.
...
|   Seriously, though, I have always disliked the separation between
|   essential and non-essential procedueres in Scheme, so if it has
|   vanished as a whole, I'm as delighted as I can be when I don't like
|   Scheme to begin with.  If it is only gone for apply, well, it's a
|   step in the right direction.
+---------------

Well, I've got some good news, and some bad news... ;-}

IEEE Standard Scheme [1991] did indeed erase the "essential/non-essential"
distinction completely, but... as of R5RS "it's BAAAAaaaack", in the form
of "primitive", "library", and "optional" syntax & procedures:

        The report is now a superset of the IEEE standard for Scheme [so]...
        The classification of features as essential or inessential has
        been removed. There are now three classes of built-in procedures:
        primitive, library, and optional. The optional procedures are
        load, with-input-from-file, with-output-to-file, transcript-on,
        transcript-off, and interaction-environment, and - and / with
        more than two arguments. None of these are in the IEEE standard.

One might reasonably question "load" being optional, but since "eval" is
now required [since everything in R5RS that is not "optional" is required],
"load" can be synthesized from other primitives.

Likewise, "with-input-from-file" & "with-output-to-file" can be emulated
with wrappers [and in any event are dangerous in the presence of errors,
since R5RS makes no guarantees about file closure on error -- "If an
escape procedure is used to escape from the continuation of these
procedures, their behavior is implementation dependent" -- whereas in
one's own implementation one can at least choose the desired behavior,
using "dynamic-wind" (except: see last item below!)].

As for the primitive/library distinction:

        1.3.1 Primitive, library, and optional features
        ...
        To aid in understanding and implementing Scheme, some features
        are marked as library. These can be easily implemented in terms
        of the other, primitive, features. They are redundant in the
        strict sense of the word, but they capture common patterns of
        usage, and are therefore provided as convenient abbreviations.

Since R5RS has "syntax-rules"-style hygenic macros as a required
primitive feature, macros can be used to implement such "library
syntax" as cond/case/and/or/let/let*/letrec/begin/do/delay, &c.

Finally, as mentioned above, "dynamic-wind" is now required, which at
least sets the stage for decent exception handling, but unfortunately
errors are *not* yet specified in terms of callinng a [top-level]
continuation, so there's still no guarantee that an error will even
invoke the "out" limb of a "dynamic-wind" at all!!  (*sigh*)

-Rob

| No, this is orthogonal to dynamic-wind.  Dynamic-wind is how you
| implement process switching, but this isn't the problem for
| with-input-from-file that Scheme has.  The problem there is
| functions that return more than once, and in those cases only the GC
| knows whether someone is holding a pointer to something that might
| be reinvoked.  Dynamic wind doesn't run unwind-protects like
| with-input-from-file would set up, but that doesn't mean there isn't
| a crisis if other kinds of escape procedures are run.  A consequence
| is that files only get closed when the gc is good and ready, and
| can't be properly closed [as a CL user would expect] reliably upon
| the point of escape.

Do I understand it correctly that you mean something like:

  (define continuation #f)

  (with-input-from-file
      "foo"
    (lambda ()
      (if (call-with-current-continuation
           (lambda (cc)
             (set! continuation cc)
             #t))
          'do-nothing
          (read-char))))

  (continuation #f)

or are you talking about something else?

--
bo...@uncommon-sense.net - <http://www.uncommon-sense.net/>