common lisp awareness


(coerce (list #\a #\b #\a #\b) 'string) ==> "abab"
(coerce (vector #\a #\b #\a #\b) 'string) ==> "abab"
(coerce "abab" 'list) ==> (#\a #\b #\a #\b)
(coerce "abab" 'vector) ==> "abab"
(map 'string #'char-invertcase "Abab") ==> "aBAB"
(map 'list #'char-invertcase "Abab") ==> (#\a #\B #\A #\B)
(map 'string #'character (list 48 49 50 51)) ==> "0123"
(sort (list 3 1 5 4) #'<) ==> (1 3 4 5)
(sort (vector 3 1 5 4) #'<) ==> #(1 3 4 5)
(sort "zzzxyxyyxyzz" #'char<) ==> "xxxyyyyzzzzz"
(elt "abafb" 3) ==> #\f
(elt (list 'a 'b 'a 'f 'b) 3) ==> F
(elt (vector 'a 'b 'a 'f 'b) 3) ==> F

You already have bignums.
That's true. But big nums don't necessarily need to support fast random access to bits. Some implementations are lists of bit chunks.

64-bit machines have more than enough memory to store text uncompressed.
If it's not optimal, it's shit.

I doubt 16-bit machine has enough horsepower to run Common Lisp
If it's not portable, it's shit.

Common Lisp doesn't support ASCII.
If it doesn't support arbitrary binary data, it's not useful enough to be considered shit.