lispdoc - results for string

(string x)

(stringp object)

strings

(string> string1 string2 &key (start1 0) end1 (start2 0) end2)

(string< string1 string2 &key (start1 0) end1 (start2 0) end2)

(string= string1 string2 &key (start1 0) end1 (start2 0) end2)

(string/= string1 string2 &key (start1 0) end1 (start2 0) end2)

(string>= string1 string2 &key (start1 0) end1 (start2 0) end2)

(string<= string1 string2 &key (start1 0) end1 (start2 0) end2)

(string-trim char-bag string)

base-string

(make-string count &key (element-type 'character) ((initial-element fill-char)))

(string-equal string1 string2 &key (start1 0) end1 (start2 0) end2)

(string-lessp string1 string2 &key (start1 0) end1 (start2 0) end2)

(write-string string &optional (stream *standard-output*) &key (start 0) end)

string-stream

(string-upcase string &key (start 0) end)

simple-string

(string-greaterp string1 string2 &key (start1 0) end1 (start2 0) end2)

(string-downcase string &key (start 0) end)

(asdf:split-string string &key max (separator '(  	)))

(string-capitalize string &key (start 0) end)

(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*))

(prin1-to-string object)

(simple-string-p object)

(princ-to-string object)

babel:unicode-string

(read-from-string string &optional (eof-error-p t) eof-value &key (start 0) end
 preserve-whitespace)

(string-left-trim char-bag string)

(string-not-equal string1 string2 &key (start1 0) end1 (start2 0) end2)

(string-not-lessp string1 string2 &key (start1 0) end1 (start2 0) end2)

(string-right-trim char-bag string)

(hunchentoot:query-string object)

(file-string-length stream object)

simple-base-string

(hunchentoot:query-string* &optional (request *request*))

(trivial-gray-streams:stream-write-string stream string &optional start end)

(string-not-greaterp string1 string2 &key (start1 0) end1 (start2 0) end2)

(cl-who:escape-string string &key (test *escape-char-p*))

(cl-ppcre:parse-string string)

(babel:octets-to-string vector &key (start 0) end
 (errorp (not *suppress-character-coding-errors*))
 (encoding *default-character-encoding*))

(babel:string-to-octets string &key (encoding *default-character-encoding*)
 (start 0) end (use-bom default)
 (errorp (not *suppress-character-coding-errors*)))

(cffi:with-foreign-string (var-or-vars lisp-string &rest args) &body body)

(cffi:foreign-string-free ptr)

alexandria.0.dev:string-designator

(cffi:with-foreign-strings bindings &body body)

(cffi:foreign-string-alloc string &key (encoding *default-foreign-encoding*)
 (null-terminated-p t) (start 0) end)

(with-output-to-string (var &optional string &key (element-type ''character))
 &body forms-decls)

babel:simple-unicode-string

(s-xml:print-string-xml string stream &key (start 0) end)

(s-xml:print-xml-string dom &key (pretty nil) (input-type lxml))

(s-xml:parse-xml-string string &key (output-type lxml))

(with-input-from-string (var string &key index start end) &body forms-decls)

(chunga:as-capitalized-string keyword)

(cl-ppcre:scan-to-strings regex target-string &key (start 0)
 (end (length target-string)) sharedp)

(cl-who:escape-string-all string)

(get-output-stream-string stream)

(make-string-input-stream string &optional (start 0) end)

(make-string-output-stream &key (element-type 'character) &aux
 (buffer (make-string *string-output-stream-buffer-initial-size*)))

(cffi:foreign-string-to-lisp pointer &key (offset 0) count
 (max-chars (1- array-total-size-limit)) (encoding *default-foreign-encoding*))

(cffi:lisp-string-to-foreign string buffer bufsize &key (start 0) end offset
 (encoding *default-foreign-encoding*))

(babel:string-size-in-octets string &key (start 0) end (max -1 maxp)
 (errorp (not *suppress-character-coding-errors*))
 (encoding *default-character-encoding*))

(trivial-backtrace:backtrace-string &rest args)

(cl-who:escape-string-minimal string)

(flexi-streams:octets-to-string sequence &key (external-format latin1)
 (start 0) (end (length sequence)))

(flexi-streams:string-to-octets string &key (external-format latin1) (start 0)
 (end (length string)))

(cl-who:escape-string-iso-8859 string)

(babel:concatenate-strings-to-octets encoding &rest strings)

(cl-ppcre:do-matches-as-strings
 (match-var regex target-string &optional result-form &key start end sharedp)
 &body body)

(cl-ppcre:all-matches-as-strings regex target-string &key (start 0)
 (end (length target-string)) sharedp)

(alexandria.0.dev:read-file-into-string pathname &key (buffer-size 4096)
 external-format)

(alexandria.0.dev:write-string-into-file string pathname &key (if-exists error)
 if-does-not-exist external-format)

(cl-base64:base64-string-to-stream input &key (uri nil) stream)

(cl-base64:string-to-base64-stream input output &key (uri nil) (columns 0))

cl-base64:stream-to-base64-string

(cl-base64:base64-string-to-string input &key (uri nil))

(cl-base64:string-to-base64-string input &key (uri nil) (columns 0))

cl-base64:base64-stream-to-string

(cl-base64:integer-to-base64-string input &key (uri nil) (columns 0))

(cl-base64:base64-string-to-integer string &key (uri nil))

(cl-ppcre:ppcre-syntax-error-string condition)

(cffi:with-foreign-pointer-as-string (var-or-vars size &rest args) &body body)

(cl-who:escape-string-iso-8859-1 string)

(cl-who:with-html-output-to-string
 (var &optional string-form &key (element-type ''character) prologue indent)
 &body body)

(cl-who:convert-tag-to-string-list tag attr-list body body-fn)

(cl-base64:base64-string-to-usb8-array input &key (uri nil))

(cl-base64:usb8-array-to-base64-string input &key (uri nil) (columns 0))

(cl-who:escape-string-minimal-plus-quotes string)