lispdoc - results for string

(string x)
Function: Coerces X into a string. If X is a string, X is returned. If X is a symbol, X's pname is returned. If X is a character then a one element string containing that character is returned. If X cannot be coerced into a string, an error occurs.
Example:
(defun eol () (string #\Newline))
Mentioned in:
CLtL2 - 11.6. Built-in Packages
CLtL2 - 13.4. Character Conversions
CLtL2 - 14.1. Simple Sequence Functions
CLtL2 - 17. Arrays
CLtL2 - 18. Strings
CLtL2 - 18.2. String Comparison
CLtL2 - 18.3. String Construction and Manipulation
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 2.5.2. Strings
CLtL2 - 29.4.2. Assertions
CLtL2 - 4.5. Type Specifiers That Specialize
CLtL2 - 4.6. Type Specifiers That Abbreviate
CLtL2 - 4.8. Type Conversion Function
CLtL2 - 4.9. Determining the Type of an Object
CLtL2 - 7.2. Generalized Variables
HyperSpec - 16.1 String Concepts
HyperSpec - 16.1.2 Subtypes of STRING
HyperSpec - Function STRING
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
HyperSpec - System Class STRING
On Lisp - Auxiliary Methods and Combination
On Lisp - Classes and Instances
On Lisp - Operations on Lists
PCL - defclass
PCL - generic functions and classes
PCL - object reorientation classes
PCL - whole sequence manipulations
Successful Lisp - characters
(stringp object)
Function: Return true if OBJECT is a STRING, and NIL otherwise.
Example:
(defun link-to-clhs? (name)
  "Returns either NIL or a link to the CLHS."
  (when (stringp name)
    (gethash (string-downcase name)
             *clhs-table*)))
Mentioned in:
CLtL2 - 18. Strings
CLtL2 - 6.2.2. Specific Data Type Predicates
HyperSpec - Function STRINGP
strings
 
 Mentioned in:
HyperSpec - 16.1.1 Implications of Strings Being Arrays
HyperSpec - 16.2 The Strings Dictionary
HyperSpec - 18.1.2.2.2 Visible Modification of Bit Vectors and Strings with respect to EQUAL
HyperSpec - 19.2.2.1 Strings in Component Values
HyperSpec - 19.3.2.2 Null Strings as Components of a Logical Pathname
HyperSpec - 22.1.3.4 Printing Strings
HyperSpec - 22.2.1.3 Compiling Format Strings
HyperSpec - 3.4.11 Syntactic Interaction of Documentation Strings and Declarations
(string> string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically greater than the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().
Example:
(defun var> (x y) (string> x y))
Mentioned in:
CLtL2 - 18.2. String Comparison
PCL - string comparisons
Successful Lisp - chapter17
(string< string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically less than the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().
 Mentioned in:
CLtL2 - 18.2. String Comparison
PCL - defining a schema
PCL - string comparisons
PCL - the database
Successful Lisp - chapter17
(string= string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings (string1 and string2), and optional integers start1, start2, end1 and end2, compares characters in string1 to characters in string2 (using char=).
Example:
(defun id3-p (file)
  (with-open-file
      (in file :element-type '(unsigned-byte 8))
    (string= "ID3"
             (read-value 'iso-8859-1-string in
              :length 3))))
Mentioned in:
CLtL2 - 10.3. Creating Symbols
CLtL2 - 11.7. Package System Functions and Variables
CLtL2 - 18.2. String Comparison
CLtL2 - 19.2. How to Use Defstruct
CLtL2 - 6.3. Equality Predicates
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
PCL - defining a schema
PCL - lookup tables alists and plists
PCL - string comparisons
PCL - the database
Successful Lisp - chapter17
(string/= string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is not lexicographically equal to the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().
 Mentioned in:
CLtL2 - 18.2. String Comparison
PCL - string comparisons
Successful Lisp - chapter17
(string>= string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically greater than or equal to the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().
 Mentioned in:
CLtL2 - 18.2. String Comparison
PCL - string comparisons
Successful Lisp - chapter17
(string<= string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically less than or equal to the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().
 Mentioned in:
CLtL2 - 18.2. String Comparison
PCL - string comparisons
Successful Lisp - chapter17
(string-trim char-bag string)
Undocumented
Example:
(defun trim-spaces (string)
  (declare (type string string))
  (string-trim (list #\  *cr* *lf* *ht*) string))
Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
HyperSpec - Function STRING-TRIM, STRING-LEFT-TRIM, STRING-RIGHT-TRIM
base-string
Undocumented
 Mentioned in:
CLtL2 - 2.5.2. Strings
CLtL2 - 9.2. Declaration Specifiers
HyperSpec - Type BASE-STRING
(make-string count &key (element-type 'character) ((initial-element fill-char)))
Function: Given a character count and an optional fill character, makes and returns a new string COUNT long filled with the fill character.
Example:
(defun %get-indent (num)
  "returns indent as string"
  (make-string (+ num +hierarchy-indent+)
               :initial-element #\ ))
Mentioned in:
CLtL2 - 14.1. Simple Sequence Functions
CLtL2 - 18.3. String Construction and Manipulation
HyperSpec - Function MAKE-STRING
Successful Lisp - characters
(string-equal string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings (string1 and string2), and optional integers start1, start2, end1 and end2, compares characters in string1 to characters in string2 (using char-equal).
Example:
(defun name-element (name)
  "Get an element from its name"
  (find-element-if
   (lambda (element)
     (string-equal (element-name element) name))))
Mentioned in:
CLtL2 - 13.4. Character Conversions
CLtL2 - 18.2. String Comparison
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 29.3.4. Object-Oriented Basis of Condition Handling
CLtL2 - 6.3. Equality Predicates
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
PCL - string comparisons
Successful Lisp - chapter17
(string-lessp string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically less than the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().
Example:
(defun title< (x y)
  (string-lessp (item-title x) (item-title y)))
Mentioned in:
CLtL2 - 6. Predicates
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
PCL - string comparisons
(write-string string &optional (stream *standard-output*) &key (start 0) end)
Undocumented
 Mentioned in:
CLtL2 - 22.3.1. Output to Character Streams
CLtL2 - 27.3. Dynamic Control of the Arrangement of Output
CLtL2 - A.2.5. Collectors
HyperSpec - Function WRITE-STRING, WRITE-LINE
PCL - anonymous functions
PCL - file output
Successful Lisp - chapter19
string-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
HyperSpec - System Class STRING-STREAM
PCL - other kinds of io
PCL - strings in binary files
(string-upcase string &key (start 0) end)
Undocumented
Example:
(defun kwd (name)
  (values (intern (string-upcase name) :keyword)))
Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
CLtL2 - 22.1.4. Standard Dispatching Macro Character Syntax
HyperSpec - Function STRING-UPCASE, STRING-DOWNCASE, STRING-CAPITALIZE, NSTRING-UPCASE, NSTRING-DOWNCASE, NSTRING-CAPITALIZE
simple-string
Undocumented
Example:
(defun unicode-string-p (string)
  "An implementation specific test for a unicode string."
  (declare (optimize speed (safety 0) (debug 0))
           (type simple-string string))
  (some #'(lambda (x) (char> x *char-marker*))
        string))
Mentioned in:
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 2.5.2. Strings
CLtL2 - 4.6. Type Specifiers That Abbreviate
CLtL2 - 4.8. Type Conversion Function
CLtL2 - 4.9. Determining the Type of an Object
HyperSpec - Type SIMPLE-STRING
(string-greaterp string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically greater than the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().
 Mentioned in:
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
PCL - string comparisons
(string-downcase string &key (start 0) end)
Undocumented
Example:
(defun symbol->query-name (sym)
  (string-downcase sym))
Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
HyperSpec - Function STRING-UPCASE, STRING-DOWNCASE, STRING-CAPITALIZE, NSTRING-UPCASE, NSTRING-DOWNCASE, NSTRING-CAPITALIZE
(asdf:split-string string &key max (separator '(  	)))
Function: Split STRING into a list of components separated by any of the characters in the sequence SEPARATOR. If MAX is specified, then no more than max(1,MAX) components will be returned, starting the separation from the end, e.g. when called with arguments "a.b.c.d.e" :max 3 :separator "." it will return ("a.b.c" "d" "e").
  
(string-capitalize string &key (start 0) end)
Undocumented
 Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
CLtL2 - 22.1.6. What the Print Function Produces
HyperSpec - Function STRING-UPCASE, STRING-DOWNCASE, STRING-CAPITALIZE, NSTRING-UPCASE, NSTRING-DOWNCASE, NSTRING-CAPITALIZE
(write-to-string object &key ((escape *print-escape*) *print-escape*)
 ((radix *print-radix*) *print-radix*) ((base *print-base*) *print-base*)
 ((circle *print-circle*) *print-circle*)
 ((pretty *print-pretty*) *print-pretty*) ((level *print-level*) *print-level*)
 ((length *print-length*) *print-length*) ((case *print-case*) *print-case*)
 ((array *print-array*) *print-array*) ((gensym *print-gensym*) *print-gensym*)
 ((readably *print-readably*) *print-readably*)
 ((right-margin *print-right-margin*) *print-right-margin*)
 ((miser-width *print-miser-width*) *print-miser-width*)
 ((lines *print-lines*) *print-lines*)
 ((pprint-dispatch *print-pprint-dispatch*) *print-pprint-dispatch*))
Function: Return the printed representation of OBJECT as a string.
Example:
(defun obj->base64 (obj)
  (base64-encode
   (with-safe-io-syntax (write-to-string obj))))
Mentioned in:
CLtL2 - 22.3.1. Output to Character Streams
CLtL2 - 28.2. Functions in the Programmer Interface
HyperSpec - Function WRITE-TO-STRING, PRIN1-TO-STRING, PRINC-TO-STRING
PCL - query parameter types
(prin1-to-string object)
Function: Return the printed representation of OBJECT as a string with slashification on.
Example:
(defun host-run-thread (id thunk)
  (process-run-function (prin1-to-string id)
   thunk))
Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
CLtL2 - 22.1.6. What the Print Function Produces
CLtL2 - 28.2. Functions in the Programmer Interface
HyperSpec - Function WRITE-TO-STRING, PRIN1-TO-STRING, PRINC-TO-STRING
(simple-string-p object)
Function: Return true if OBJECT is a SIMPLE-STRING, and NIL otherwise.
Example:
(defun special-string-p (string)
  (and (simple-string-p string)
       (gethash string *special-strings*)))
Mentioned in:
CLtL2 - 6.2.2. Specific Data Type Predicates
HyperSpec - Function SIMPLE-STRING-P
(princ-to-string object)
Function: Return the printed representation of OBJECT as a string with slashification off.
Example:
(defun show-warning (warn)
  (error-popup (princ-to-string warn) "Warning"
   :warning))
Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
CLtL2 - 22.3.1. Output to Character Streams
CLtL2 - 28.2. Functions in the Programmer Interface
HyperSpec - Function WRITE-TO-STRING, PRIN1-TO-STRING, PRINC-TO-STRING
PCL - the basic evaluation rule
PCL - the foo language
babel:unicode-string
Type: Alias for (VECTOR UNICODE-CHAR *).
  
(read-from-string string &optional (eof-error-p t) eof-value &key (start 0) end
 preserve-whitespace)
Function: The characters of string are successively given to the lisp reader and the lisp object built by the reader is returned. Macro chars will take effect.
Example:
(defun base64->obj (string)
  (ignore-errors
   (with-safe-io-syntax
    (read-from-string (base64-decode string)))))
Mentioned in:
CLtL2 - 22.2.1. Input from Character Streams
CLtL2 - Appendix C.
HyperSpec - Function READ-FROM-STRING
On Lisp - Operations on Lists
PCL - anonymous functions
PCL - query parameter types
Successful Lisp - chapter21
(string-left-trim char-bag string)
Undocumented
 Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
HyperSpec - Function STRING-TRIM, STRING-LEFT-TRIM, STRING-RIGHT-TRIM
(string-not-equal string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is not lexicographically equal to the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().
 Mentioned in:
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
PCL - string comparisons
Successful Lisp - chapter17
(string-not-lessp string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically greater than or equal to the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().
 Mentioned in:
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
PCL - string comparisons
(string-right-trim char-bag string)
Undocumented
 Mentioned in:
CLtL2 - 18.3. String Construction and Manipulation
HyperSpec - Function STRING-TRIM, STRING-LEFT-TRIM, STRING-RIGHT-TRIM
(hunchentoot:query-string object)
Undocumented
  
(file-string-length stream object)
Undocumented
 Mentioned in:
CLtL2 - 23.3. Renaming, Deleting, and Other File Operations
HyperSpec - Function FILE-STRING-LENGTH
simple-base-string
Undocumented
 Mentioned in:
CLtL2 - 2.5.2. Strings
HyperSpec - Type SIMPLE-BASE-STRING
(hunchentoot:query-string* &optional (request *request*))
Function: Returns the query string of the REQUEST object REQUEST. That's the part behind the question mark (i.e. the GET parameters).
  
(trivial-gray-streams:stream-write-string stream string &optional start end)
Function: This is used by WRITE-STRING. It writes the string to the stream, optionally delimited by start and end, which default to 0 and NIL. The string argument is returned. The default method provided by FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to STREAM-WRITE-CHAR.
  
(string-not-greaterp string1 string2 &key (start1 0) end1 (start2 0) end2)
Function: Given two strings, if the first string is lexicographically less than or equal to the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().
 Mentioned in:
HyperSpec - Function STRING=, STRING/=, STRING<, STRING>, STRING<=, STRING>=, STRING-EQUAL, STRING-NOT-EQUAL, STRING-LESSP, STRING-GREATERP, STRING-NOT-GREATERP, STRING-NOT-LESSP
PCL - string comparisons
(cl-who:escape-string string &key (test *escape-char-p*))
Function: Escape all characters in STRING which pass TEST. This function is not guaranteed to return a fresh string. Note that you can pass NIL for STRING which'll just be returned.
  
(cl-ppcre:parse-string string)
Function: Translate the regex string STRING into a parse tree.
  
(babel:octets-to-string vector &key (start 0) end
 (errorp (not *suppress-character-coding-errors*))
 (encoding *default-character-encoding*))
Undocumented
  
(babel:string-to-octets string &key (encoding *default-character-encoding*)
 (start 0) end (use-bom default)
 (errorp (not *suppress-character-coding-errors*)))
Undocumented
  
(cffi:with-foreign-string (var-or-vars lisp-string &rest args) &body body)
Function: VAR-OR-VARS is not evaluated ans should a list of the form (VAR &OPTIONAL BYTE-SIZE-VAR) or just a VAR symbol. VAR is bound to a foreign string containing LISP-STRING in BODY. When BYTE-SIZE-VAR is specified then bind the C buffer size (including the possible null terminator(s)) to this variable.
  
(cffi:foreign-string-free ptr)
Function: Free a foreign string allocated by FOREIGN-STRING-ALLOC.
  
alexandria.0.dev:string-designator
Type: A string designator type. A string designator is either a string, a symbol, or a character.
  
(cffi:with-foreign-strings bindings &body body)
Function: See WITH-FOREIGN-STRING's documentation.
  
(cffi:foreign-string-alloc string &key (encoding *default-foreign-encoding*)
 (null-terminated-p t) (start 0) end)
Function: Allocate a foreign string containing Lisp string STRING. The string must be freed with FOREIGN-STRING-FREE.
  
(with-output-to-string (var &optional string &key (element-type ''character))
 &body forms-decls)
Undocumented
Example:
(defun process-coords (input)
  (with-output-to-string (s)
    (format-number s input)))
Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
CLtL2 - 9.1. Declaration Syntax
HyperSpec - Macro WITH-OUTPUT-TO-STRING
On Lisp - Symbols and Strings
PCL - other kinds of io
PCL - strings in binary files
Successful Lisp - chapter19
babel:simple-unicode-string
Type: Alias for (SIMPLE-ARRAY UNICODE-CHAR (*)).
  
(s-xml:print-string-xml string stream &key (start 0) end)
Function: Write the characters of string to stream using basic XML conventions
  
(s-xml:print-xml-string dom &key (pretty nil) (input-type lxml))
Function: Generate XML output to a string from a DOM of input-type (:lxml by default), optionally pretty printing (off by default)
  
(s-xml:parse-xml-string string &key (output-type lxml))
Function: Parse a string as XML and generate a DOM of output-type, defaulting to :lxml
  
(with-input-from-string (var string &key index start end) &body forms-decls)
Undocumented
Example:
(defun retest (str)
  (with-input-from-string (is str) (read is)))
Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
CLtL2 - 9.1. Declaration Syntax
HyperSpec - Macro WITH-INPUT-FROM-STRING
PCL - other kinds of io
Successful Lisp - chapter19
(chunga:as-capitalized-string keyword)
Function: Kind of the inverse of AS-KEYWORD. Has essentially the same effect as STRING-CAPITALIZE but is optimized for "known" keywords like :CONTENT-LENGTH or :GET.
  
(cl-ppcre:scan-to-strings regex target-string &key (start 0)
 (end (length target-string)) sharedp)
Function: Like SCAN but returns substrings of TARGET-STRING instead of positions, i.e. this function returns two values on success: the whole match as a string plus an array of substrings (or NILs) corresponding to the matched registers. If SHAREDP is true, the substrings may share structure with TARGET-STRING.
Compiler-Macro: Make sure that constant forms are compiled into scanners at compile time.
  
(cl-who:escape-string-all string)
Function: Escapes all characters in STRING which aren't in the 7-bit ASCII character set.
  
(get-output-stream-string stream)
Undocumented
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function GET-OUTPUT-STREAM-STRING
PCL - other kinds of io
(make-string-input-stream string &optional (start 0) end)
Function: Return an input stream which will supply the characters of STRING between START and END in order.
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
CLtL2 - 7.9. Structure Traversal and Side Effects
HyperSpec - Function MAKE-STRING-INPUT-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(make-string-output-stream &key (element-type 'character) &aux
 (buffer (make-string *string-output-stream-buffer-initial-size*)))
Function: Return an output stream which will accumulate all output given it for the benefit of the function GET-OUTPUT-STREAM-STRING.
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function MAKE-STRING-OUTPUT-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(cffi:foreign-string-to-lisp pointer &key (offset 0) count
 (max-chars (1- array-total-size-limit)) (encoding *default-foreign-encoding*))
Function: Copy at most COUNT bytes from POINTER plus OFFSET encoded in ENCODING into a Lisp string and return it. If POINTER is a null pointer, NIL is returned.
  
(cffi:lisp-string-to-foreign string buffer bufsize &key (start 0) end offset
 (encoding *default-foreign-encoding*))
Undocumented
  
(babel:string-size-in-octets string &key (start 0) end (max -1 maxp)
 (errorp (not *suppress-character-coding-errors*))
 (encoding *default-character-encoding*))
Undocumented
  
(trivial-backtrace:backtrace-string &rest args)
Undocumented
  
(cl-who:escape-string-minimal string)
Function: Escapes only #<, #>, and #& in STRING.
  
(flexi-streams:octets-to-string sequence &key (external-format latin1)
 (start 0) (end (length sequence)))
Function: Converts the Lisp sequence SEQUENCE of octets from START to END to a string using the external format designated by EXTERNAL-FORMAT. This function is optimized for the case of SEQUENCE being a vector. Don't use lists if you're in a hurry.
  
(flexi-streams:string-to-octets string &key (external-format latin1) (start 0)
 (end (length string)))
Function: Converts the Lisp string STRING from START to END to an array of octets corresponding to the external format designated by EXTERNAL-FORMAT. In spite of the name, STRING can be any sequence of characters, but the function is optimized for strings.
  
(cl-who:escape-string-iso-8859 string)
Function: Identical to ESCAPE-STRING-8859-1. Kept for backward compatibility.
  
(babel:concatenate-strings-to-octets encoding &rest strings)
Function: Optimized equivalent of (string-to-octets (apply #'concatenate 'string strings) :encoding encoding)
  
(cl-ppcre:do-matches-as-strings
 (match-var regex target-string &optional result-form &key start end sharedp)
 &body body)
Function: Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with MATCH-VAR bound to the substring of TARGET-STRING corresponding to each match in turn. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-MATCHES-AS-STRINGS; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING. BODY may start with declarations.
  
(cl-ppcre:all-matches-as-strings regex target-string &key (start 0)
 (end (length target-string)) sharedp)
Function: Returns a list containing all substrings of TARGET-STRING which match REGEX. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING.
Compiler-Macro: Make sure that constant forms are compiled into scanners at compile time.
Example:
(defun extract-words (text)
  (delete-duplicates
   (cl-ppcre:all-matches-as-strings
    "[a-zA-Z]{3,}" text)
   :test #'string=))
 
(alexandria.0.dev:read-file-into-string pathname &key (buffer-size 4096)
 external-format)
Function: Return the contents of the file denoted by PATHNAME as a fresh string. The EXTERNAL-FORMAT parameter will be passed directly to WITH-OPEN-FILE unless it's NIL, which means the system default.
  
(alexandria.0.dev:write-string-into-file string pathname &key (if-exists error)
 if-does-not-exist external-format)
Function: Write STRING to PATHNAME. The EXTERNAL-FORMAT parameter will be passed directly to WITH-OPEN-FILE unless it's NIL, which means the system default.
  
(cl-base64:base64-string-to-stream input &key (uri nil) stream)
Function: Decode base64 string to stream
  
(cl-base64:string-to-base64-stream input output &key (uri nil) (columns 0))
Function: Encode a string array to base64. If columns is > 0, designates maximum number of columns in a line and the string will be terminated with a #Newline.
  
cl-base64:stream-to-base64-string
Undocumented
  
(cl-base64:base64-string-to-string input &key (uri nil))
Function: Decode base64 string to string
  
(cl-base64:string-to-base64-string input &key (uri nil) (columns 0))
Function: Encode a string array to base64. If columns is > 0, designates maximum number of columns in a line and the string will be terminated with a #Newline.
  
cl-base64:base64-stream-to-string
Undocumented
  
(cl-base64:integer-to-base64-string input &key (uri nil) (columns 0))
Function: Encode an integer to base64 format.
  
(cl-base64:base64-string-to-integer string &key (uri nil))
Function: Decodes a base64 string to an integer
  
(cl-ppcre:ppcre-syntax-error-string condition)
Function: Returns the string the parser was parsing when the error was encountered (or NIL if the error happened while trying to convert a parse tree).
  
(cffi:with-foreign-pointer-as-string (var-or-vars size &rest args) &body body)
Function: VAR-OR-VARS is not evaluated and should be a list of the form (VAR &OPTIONAL SIZE-VAR) or just a VAR symbol. VAR is bound to a foreign buffer of size SIZE within BODY. The return value is constructed by calling FOREIGN-STRING-TO-LISP on the foreign buffer along with ARGS.
  
(cl-who:escape-string-iso-8859-1 string)
Function: Escapes all characters in STRING which aren't defined in ISO-8859-1.
  
(cl-who:with-html-output-to-string
 (var &optional string-form &key (element-type ''character) prologue indent)
 &body body)
Function: Transform the enclosed BODY consisting of HTML as s-expressions into Lisp code which creates the corresponding HTML as a string.
  
(cl-who:convert-tag-to-string-list tag attr-list body body-fn)
Function: Used by PROCESS-TAG to convert `HTML' into a list of strings. TAG is a keyword symbol naming the outer tag, ATTR-LIST is an alist of its attributes (the car is the attribute's name as a keyword, the cdr is its value), BODY is the tag's body, and BODY-FN is a function which should be applied to BODY. The function must return a list of strings or Lisp forms.
  
(cl-base64:base64-string-to-usb8-array input &key (uri nil))
Function: Decode base64 string to usb8-array
  
(cl-base64:usb8-array-to-base64-string input &key (uri nil) (columns 0))
Function: Encode a string array to base64. If columns is > 0, designates maximum number of columns in a line and the string will be terminated with a #Newline.
  
(cl-who:escape-string-minimal-plus-quotes string)
Function: Like ESCAPE-STRING-MINIMAL but also escapes quotes.