The str Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The str Reference Manual

This is the str Reference Manual, version 0.8, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:24:42 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

A modern and consistent Common Lisp string manipulation library

(ql:quickload "str")

Why ?

The only dependency is cl-ppcre.

Table of Contents

Install

Install with Quicklisp:

(ql:quickload :str)

Check its version:

(str:version)

To get a newer version, you need to update the Quicklisp dist (think of QL as Debian's apt rather than pip/npm/etc):

(ql:update-dist "quicklisp")

beware, this is a young and unstable library. (update v0.7) The functions implementation may change, but we shouldn't change the api.

(don't have a full Common Lisp development environment yet ? Get Portacle, a portable and multiplatform development environment shipping Emacs, Quicklisp, SBCL and Git).

Functions

Tweak whitespace

trim (s)

Remove whitespaces at the beginning and end of s.

(trim "  rst  ") ;; => "rst"

Also trim-left and trim-right.

Uses the built-in string-trim where whitespaces are '(#\Space #\Newline #\Backspace #\Tab #\Linefeed #\Page #\Return #\Rubout).

To longer strings

join (separator list-of-strings)

Join strings in list list-of-strings with separator in between.

(join " " '("foo" "bar" "baz")) ;; => "foo bar baz"

Uses a specific format syntax.

concat (&rest strings)

Join strings into one.

(concat "f" "o" "o") ;; => "foo"

Simple call of the built-in concatenate.

repeat (count s)

Make a string of s repeated count times.

(repeat 3 "foo") ;; => "foofoofoo"

To shorter strings

Substring (start end s)

Return the substring of s from start to end.

It uses subseq with differences:

Examples:

  (is "abcd" (substring 0 t "abcd") "t denotes the end of the string")
  (is "abcd" (substring 0 nil "abcd") "nil too")
  (is "abcd" (substring 0 100 "abcd") "end can be too large")
  (is "abc" (substring 0 -1 "abcd") "end can be negative. Counts from the end.")
  (is "" (substring 0 -100 "abcd") "end can be negative and too low")
  (is "" (substring 100 1 "abcd") "start can be too big")
  (is "abcd" (substring -100 4 "abcd") "start can also be too low")
  (is "" (substring 2 1 "abcd") "start is bigger than end")

To and from lists

words (s)

Return list of words, which were delimited by whitespace.

unwords (strings)

Join the list of strings with a whitespace.

lines (s)

Split string by newline character and return list of lines.

unlines (strings)

Join the list of strings with a newline character.

split (separator s &key omit-nulls)

Split into subtrings (unlike cl-ppcre, without a regexp). If omit-nulls is non-nil, zero-length substrings are omitted.

(split "+" "foo++bar") ;; => ("foo" "" "bar")
(split "+" "foo++bar" :omit-nulls t) ;; => ("foo" "bar")

Wrapper around cl-ppcre:split but:

(cl-ppcre:split "," ",a,b,,c,") ;; => ("" "a" "b" "" "c")

and we return a trailing "":

(split "," ",a,b,,c,") ;; => ("" "a" "b" "" "c" "")

split-omit-nulls (in v0.6, QL january 2018)

Because it is a common pattern and it can be clearer than an option coming after many parenthesis.

To and from files (experimental in v0.4)

from-file (filename)

Read the file and return its content as a string.

Example: (str:from-file "path/to/file.txt").

:external-format: if nil, the system default. Can be bound to :utf-8.

But you might just call uiop's uiop:read-file-string directly.

There is also uiop:read-file-lines.

to-file (filename s)

Write the string s to the file filename. If the file does not exist, create it, if it already exists, replace it.

Options:

Returns the string written to file.

Predicates

empty?, emptyp (s)

True if s is nil or the empty string:

  (empty? nil) ;; => T
  (empty? "")  ;; => T
  (empty? " ") ;; => NIL

blank?, blankp (s)

True if s is empty or only contains whitespaces.

(blankp "") ;; => T
(blankp " ") ;; => T
(emptyp " ") ;; => NIL

starts-with?, starts-with-p (start s &key ignore-case)

True if s starts with the substring start, nil otherwise. Ignore case by default.

(starts-with? "foo" "foobar") ;; => T
(starts-with? "FOO" "foobar") ;; => NIL
(starts-with? "FOO" "foobar" :ignore-case t) ;; => T

Calls string= or string-equal depending on the case, with their :start and :end delimiters.

ends-with?, ends-with-p (end s &key ignore-case)

True if s ends with the substring end. Ignore case by default.

(ends-with? "bar" "foobar") ;; => T

contains?, containsp (substring s &key (ignore-case nil))

Return true if s contains substring, nil otherwise. Ignore the case with :ignore-case t (don't ignore by default).

Based on a simple call to the built-in search (which returns the position of the substring).

Others

replace-all (old new s)

Replace old by new (no regexs) in s.

(replace-all "a" "o" "faa") ;; => "foo"

Uses cl-ppcre:regex-replace-all but quotes the user input to not treat it as a regex.

common-prefix (list-of-strings) new in v0.5

Find the common prefix between strings.

Example: (str:common-prefix '(\"foobar\" \"foozz\")) => "foo"

Uses the built-in mismatch, that returns the position at which the strings fail to match.

Return a string or nil when the input is the void list.

Macros

string-case (new in v0.8, Quicklisp end of february 2018)

A case-like macro that works with strings (CL's case only works with symbols).

Example:

(str:string-case input
  ("foo" (do something))
  (nil (print "input is nil")
  (otherwise (print "non of the previous forms was caught.")))

You might also like pattern matching. The example below with optima is very similar:

(optima:match "hey"
  ("hey" (print "it matched"))
  (otherwise :nothing))

Note that there is also http://quickdocs.org/string-case/.

Changelog

Dev and test

Test with prove.

See also

Inspired by the famous Emacs Lisp's s.el.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 str

Maintainer

vindarel <vindarel@mailz.org>

Author

vindarel <vindarel@mailz.org>

Home Page

https://github.com/vindarel/cl-str

Source Control

(:git "git@github.com:vindarel/cl-s.git")

Bug Tracker

https://github.com/vindarel/cl-str/issues

License

MIT

Description

Modern, consistent and terse Common Lisp string manipulation library.

Long Description

# A modern and consistent Common Lisp string manipulation library

(ql:quickload "str")

Why ?

* modernity, simplicity and discoverability:

- ‘(str:trim s)‘ instead of ‘ (string-trim ’(#\Space #\Newline #\Backspace #\Tab #\Linefeed #\Page #\Return #\Rubout) s))‘,
or ‘str:concat strings‘ instead of an unusual ‘format‘ construct; one discoverable library instead of many;

* consistance and composability, where ‘s‘ is always the last argument, which makes it
easier to feed pipes and arrows.

The only dependency is ‘cl-ppcre‘.

<!– markdown-toc start - Don’t edit this section. Run M-x markdown-toc-generate-toc again –>
**Table of Contents**

- [A modern and consistent Common Lisp string manipulation library](#a-modern-and-consistent-common-lisp-string-manipulation-library) - [Install](#install)
- [Functions](#functions)
- [Tweak whitespace](#tweak-whitespace)
- [trim ‘(s)‘](#trim-s)
- [To longer strings](#to-longer-strings)
- [join ‘(separator list-of-strings)‘](#join-separator-list-of-strings)
- [concat ‘(&rest strings)‘](#concat-rest-strings)
- [repeat ‘(count s)‘](#repeat-count-s)
- [To shorter strings](#to-shorter-strings)
- [Substring ‘(start end s)‘](#substring-start-end-s)
- [To and from lists](#to-and-from-lists)
- [words ‘(s)‘](#words-s)
- [unwords ‘(strings)‘](#unwords-strings)
- [lines ‘(s)‘](#lines-s)
- [unlines ‘(strings)‘](#unlines-strings)
- [split ‘(separator s &key omit-nulls)‘](#split-separator-s-key-omit-nulls)
- [split-omit-nulls (in v0.6, QL january 2018)](#split-omit-nulls–in-v06-ql-january-2018)
- [To and from files (experimental in v0.4)](#to-and-from-files-experimental-in-v04)
- [from-file ‘(filename)‘](#from-file-filename)
- [to-file ‘(filename s)‘](#to-file-filename-s)
- [Predicates](#predicates)
- [empty?, emptyp ‘(s)‘](#empty-emptyp-s)
- [blank?, blankp ‘(s)‘](#blank-blankp-s)
- [starts-with?, starts-with-p ‘(start s &key ignore-case)‘](#starts-with-starts-with-p-start-s-key-ignore-case)
- [ends-with?, ends-with-p ‘(end s &key ignore-case)‘](#ends-with-ends-with-p-end-s-key-ignore-case)
- [contains?, containsp ‘(substring s &key (ignore-case nil))‘](#contains-containsp-substring-s-key-ignore-case-nil) - [Others](#others)
- [replace-all ‘(old new s)‘](#replace-all-old-new-s)
- [common-prefix ‘(list-of-strings)‘ new in v0.5](#common-prefix-list-of-strings-new-in-v05)
- [Macros](#macros)
- [string-case](#string-case)
- [Changelog](#changelog)
- [Dev and test](#dev-and-test)
- [See also](#see-also)

<!– markdown-toc end –>

## Install

Install with [Quicklisp](https://www.quicklisp.org/beta/):

(ql:quickload :str)

Check its version:

(str:version)

To get a newer version, you need to update the Quicklisp dist (think
of QL as Debian’s apt rather than pip/npm/etc):

(ql:update-dist "quicklisp")

beware, this is a young and unstable library. (update v0.7) The
functions implementation may change, but we shouldn’t change the api.

(don’t have a full Common Lisp development environment yet ? Get
[Portacle](https://shinmera.github.io/portacle/), a portable and
multiplatform development environment shipping Emacs, Quicklisp, SBCL
and Git).

## Functions

### Tweak whitespace

#### trim ‘(s)‘
Remove whitespaces at the beginning and end of ‘s‘.

“‘cl
(trim " rst ") ;; => "rst"
“‘

Also ‘trim-left‘ and ‘trim-right‘.

Uses the built-in [string-trim](https://lispcookbook.github.io/cl-cookbook/strings.html#trimming-blanks-from-the-ends-of-a-string)
where whitespaces are ‘’(#\Space #\Newline #\Backspace #\Tab #\Linefeed #\Page #\Return #\Rubout)‘.

### To longer strings

#### join ‘(separator list-of-strings)‘

Join strings in list ‘list-of-strings‘ with ‘separator‘ in between.

“‘cl
(join " " ’("foo" "bar" "baz")) ;; => "foo bar baz"
“‘

Uses a specific [format](http://jtra.cz/stuff/lisp/sclr/format.html) syntax.

#### concat ‘(&rest strings)‘

Join strings into one.

“‘cl
(concat "f" "o" "o") ;; => "foo"
“‘

Simple call of the built-in [concatenate](https://lispcookbook.github.io/cl-cookbook/strings.html#concatenating-strings).

#### repeat ‘(count s)‘

Make a string of ‘s‘ repeated ‘count‘ times.

“‘cl
(repeat 3 "foo") ;; => "foofoofoo"
“‘

### To shorter strings

#### Substring ‘(start end s)‘

Return the substring of ‘s‘ from ‘start‘ to ‘end‘.

It uses ‘subseq‘ with differences:

* argument order, s at the end
* ‘start‘ and ‘end‘ can be lower than 0 or bigger than the length of s.
* for convenience ‘end‘ can be nil or t to denote the end of the string.

Examples:

“‘lisp
(is "abcd" (substring 0 t "abcd") "t denotes the end of the string")
(is "abcd" (substring 0 nil "abcd") "nil too")
(is "abcd" (substring 0 100 "abcd") "end can be too large")
(is "abc" (substring 0 -1 "abcd") "end can be negative. Counts from the end.")
(is "" (substring 0 -100 "abcd") "end can be negative and too low")
(is "" (substring 100 1 "abcd") "start can be too big")
(is "abcd" (substring -100 4 "abcd") "start can also be too low")
(is "" (substring 2 1 "abcd") "start is bigger than end")
“‘

### To and from lists

#### words ‘(s)‘

Return list of words, which were delimited by whitespace.

#### unwords ‘(strings)‘

Join the list of strings with a whitespace.

#### lines ‘(s)‘

Split string by newline character and return list of lines.

#### unlines ‘(strings)‘

Join the list of strings with a newline character.

#### split ‘(separator s &key omit-nulls)‘

Split into subtrings (unlike cl-ppcre, without a regexp). If
‘omit-nulls‘ is non-nil, zero-length substrings are omitted.

“‘cl
(split "+" "foo++bar") ;; => ("foo" "" "bar")
(split "+" "foo++bar" :omit-nulls t) ;; => ("foo" "bar")
“‘

Wrapper around [cl-ppcre:split](http://weitz.de/cl-ppcre/#split) but:

- our separator is a simple string, where cl-ppcre takes a regexp,
- we fix an inconsistency:

“‘
(cl-ppcre:split "," ",a,b,,c,") ;; => ("" "a" "b" "" "c")
“‘

and we return a trailing ‘""‘:

(split "," ",a,b,,c,") ;; => ("" "a" "b" "" "c" "")

#### split-omit-nulls (in v0.6, QL january 2018)

Because it is a common pattern and it can be clearer than an option
coming after many parenthesis.

### To and from files (experimental in v0.4)

#### from-file ‘(filename)‘

Read the file and return its content as a string.

Example: ‘(str:from-file "path/to/file.txt")‘.

‘:external-format‘: if nil, the system default. Can be bound to ‘:utf-8‘.

But you might just call
[uiop’s ‘uiop:read-file-string‘](https://github.com/fare/asdf/blob/master/uiop/stream.lisp#L445)
directly.

There is also ‘uiop:read-file-lines‘.

#### to-file ‘(filename s)‘

Write the string ‘s‘ to the file ‘filename‘. If the file does not
exist, create it, if it already exists, replace it.

Options:

* ‘:if-does-not-exist‘: ‘:create‘ (default), ‘:error‘
* ‘:if-exists‘: ‘:supersede‘ (default), ‘:append‘, ‘:overwrite‘, ‘:rename‘, ‘:error‘,...

Returns the string written to file.

### Predicates

#### empty?, emptyp ‘(s)‘

True if ‘s‘ is nil or the empty string:

“‘cl
(empty? nil) ;; => T
(empty? "") ;; => T
(empty? " ") ;; => NIL
“‘

#### blank?, blankp ‘(s)‘

True if ‘s‘ is empty or only contains whitespaces.

(blankp "") ;; => T
(blankp " ") ;; => T
(emptyp " ") ;; => NIL

#### starts-with?, starts-with-p ‘(start s &key ignore-case)‘

True if ‘s‘ starts with the substring ‘start‘, nil otherwise. Ignore
case by default.

(starts-with? "foo" "foobar") ;; => T
(starts-with? "FOO" "foobar") ;; => NIL
(starts-with? "FOO" "foobar" :ignore-case t) ;; => T

Calls ‘string=‘ or ‘string-equal‘ depending on the case, with their
‘:start‘ and ‘:end‘ delimiters.

#### ends-with?, ends-with-p ‘(end s &key ignore-case)‘

True if ‘s‘ ends with the substring ‘end‘. Ignore case by default.

(ends-with? "bar" "foobar") ;; => T

#### contains?, containsp ‘(substring s &key (ignore-case nil))‘

Return true if ‘s‘ contains ‘substring‘, nil otherwise. Ignore the
case with ‘:ignore-case t‘ (don’t ignore by default).

Based on a simple call to the built-in ‘search‘ (which returns the
position of the substring).

### Others

#### replace-all ‘(old new s)‘

Replace ‘old‘ by ‘new‘ (no regexs) in ‘s‘.

“‘cl
(replace-all "a" "o" "faa") ;; => "foo"
“‘

Uses
[cl-ppcre:regex-replace-all](http://weitz.de/cl-ppcre/#regex-replace-all)
but quotes the user input to not treat it as a regex.

#### common-prefix ‘(list-of-strings)‘ new in v0.5

Find the common prefix between strings.

Example: ‘(str:common-prefix ’(\"foobar\" \"foozz\"))‘ => \"foo\"

Uses the built-in ‘mismatch‘, that returns the position at which
the strings fail to match.

Return a string or nil when the input is the void list.

## Macros

### string-case (new in v0.8, Quicklisp end of february 2018)

A case-like macro that works with strings (CL’s case only works with symbols).

Example:

~~~lisp
(str:string-case input
("foo" (do something))
(nil (print "input is nil")
(otherwise (print "non of the previous forms was caught.")))
~~~

You might also like pattern matching. The example below with
[optima](https://github.com/m2ym/optima) is very similar:

~~~lisp
(optima:match "hey"
("hey" (print "it matched"))
(otherwise :nothing))
~~~

Note that there is also http://quickdocs.org/string-case/.

## Changelog

* 0.8 added ‘string-case‘
* 0.7 added ‘version‘
* 0.6 added ‘split-omit-nulls‘ (QL, january 2018)
* 0.5 added ‘common-prefix‘
* 0.4 added ‘from-file‘ and ‘to-file‘.
* 0.3 added ‘substring‘.

## Dev and test

Test with [prove](https://github.com/fukamachi/prove).

## See also

* [cl-strings](https://github.com/diogoalexandrefranco/cl-strings), a
similar (discovered afterwards), maybe more complete library, that
does not use established libraries as dependencies as we do (with
*potential* implementation
[issues](https://github.com/diogoalexandrefranco/cl-strings/issues/2)).
* [cl-change-case](https://github.com/rudolfochrist/cl-change-case) to
convert strings between camelCase, param-case, snake_case and more.
* the [Common Lisp Cookbook](https://lispcookbook.github.io/cl-cookbook/strings.html), strings page.

Inspired by the famous Emacs Lisp’s [s.el](https://github.com/magnars/s.el).

Version

0.8

Dependency

cl-ppcre

Source

str.asd (file)

Component

str.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 str.asd

Location

str.asd

Systems

str (system)


Previous: , Up: Lisp files   [Contents][Index]

3.1.2 str/str.lisp

Parent

str (system)

Location

str.lisp

Packages

str

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 str

Source

str.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: +version+
Package

str

Source

str.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: string-case STR &rest FORMS

A case-like macro that works with strings (case works only with symbols).

Example:

(str:string-case input
("foo" (do something))
(nil (print "input is nil")
(otherwise (print "none of the previous forms was caught")))

You might also like pattern matching. The example below with optima is very similar:

(optima:match "hey"
("hey" (print "it matched"))
(otherwise :nothing))

Note that there is also http://quickdocs.org/string-case/.

Package

str

Source

str.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: blank? S

Is s nil or only contains whitespaces ?

Package

str

Source

str.lisp (file)

Function: blankp S

Is s nil or only contains whitespaces ?

Package

str

Source

str.lisp (file)

Function: common-prefix ITEMS

Find the common prefix between strings.

Uses the built-in ‘mismatch’, that returns the position at which the strings fail to match.

Example: ‘(str:common-prefix ’("foobar" "foozz"))‘ => "foo"

- items: list of strings
- Return: a string.

Package

str

Source

str.lisp (file)

Function: concat &rest STRINGS

Join all the string arguments into one string.

Package

str

Source

str.lisp (file)

Function: contains? SUBSTRING S &key IGNORE-CASE

Return ‘t‘ if ‘s‘ contains ‘substring‘, nil otherwise. Ignore the case with ‘:ignore-case t‘. A simple call to the built-in ‘search‘ (which returns the position of the substring).

Package

str

Source

str.lisp (file)

Function: containsp SUBSTRING S &key IGNORE-CASE

Return ‘t‘ if ‘s‘ contains ‘substring‘, nil otherwise. Ignore the case with ‘:ignore-case t‘. A simple call to the built-in ‘search‘ (which returns the position of the substring).

Package

str

Source

str.lisp (file)

Function: empty? S

Is s nil or the empty string ?

Package

str

Source

str.lisp (file)

Function: emptyp S

Is s nil or the empty string ?

Package

str

Source

str.lisp (file)

Function: ends-with-p END S &key IGNORE-CASE

Return t if s ends with the substring ’end’, nil otherwise.

Package

str

Source

str.lisp (file)

Function: ends-with? END S &key IGNORE-CASE

Return t if s ends with the substring ’end’, nil otherwise.

Package

str

Source

str.lisp (file)

Function: from-file PATHNAME &rest KEYS

Read the file and return its content as a string.

From v0.7 simply uses uiop:read-file-string. There is also read-file-lines.

Example: (str:from-file "path/to/file.txt" :external-format :utf-8)

- external-format: if nil, the system default. Can be bound to :utf-8.

Package

str

Source

str.lisp (file)

Function: join SEPARATOR STRINGS
Package

str

Source

str.lisp (file)

Function: lines S &key OMIT-NULLS

Split the string by newline characters and return a list of lines.

Package

str

Source

str.lisp (file)

Function: repeat COUNT S

Make a string of S repeated COUNT times.

Package

str

Source

str.lisp (file)

Function: replace-all OLD NEW S

Replace ‘old‘ by ‘new‘ in ‘s‘. Arguments are not regexs.

Package

str

Source

str.lisp (file)

Function: split SEPARATOR S &key OMIT-NULLS

Split s into substring by separator (cl-ppcre takes a regex, we do not).

Package

str

Source

str.lisp (file)

Function: split-omit-nulls SEPARATOR S

Call split with :omit-nulls to t.

Can be clearer in certain situations.

Package

str

Source

str.lisp (file)

Function: starts-with-p START S &key IGNORE-CASE

Return t if s starts with the substring ’start’, nil otherwise.

Package

str

Source

str.lisp (file)

Function: starts-with? START S &key IGNORE-CASE

Return t if s starts with the substring ’start’, nil otherwise.

Package

str

Source

str.lisp (file)

Function: substring START END S

Return the substring of ‘s’ from ‘start’ to ‘end’.

It uses ‘subseq’ with differences:
- argument order, s at the end
- ‘start’ and ‘end’ can be lower than 0 or bigger than the length of s. - for convenience ‘end’ can be nil or t to denote the end of the string.

Package

str

Source

str.lisp (file)

Function: to-file PATHNAME S &key IF-EXISTS IF-DOES-NOT-EXIST

Write string ‘s’ to file ‘pathname’. If the file does not exist, create it (use ‘:if-does-not-exist’), if it already exists, replace its content (‘:if-exists’).

Returns the string written to file.

Package

str

Source

str.lisp (file)

Function: trim S

Remove whitespaces at the beginning and end of s. @begin[lang=lisp](code)
(trim " foo ") ;; => "foo"
@end(code)

Package

str

Source

str.lisp (file)

Function: trim-left S

Remove whitespaces at the beginning of s.

Package

str

Source

str.lisp (file)

Function: trim-right S

Remove whitespaces at the end of s.

Package

str

Source

str.lisp (file)

Function: unlines STRINGS

Join the list of strings with a newline character.

Package

str

Source

str.lisp (file)

Function: unwords STRINGS

Join the list of strings with a whitespace.

Package

str

Source

str.lisp (file)

Function: version ()
Package

str

Source

str.lisp (file)

Function: words S &key LIMIT

Return list of words, which were delimited by white space. If the optional limit is 0 (the default), trailing empty strings are removed from the result list (see cl-ppcre).

Package

str

Source

str.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *whitespaces*
Package

str

Source

str.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: common-prefix-1 ITEM1 ITEM2
Package

str

Source

str.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   S  
Index Entry  Section

F
File, Lisp, str.asd: The str<dot>asd file
File, Lisp, str/str.lisp: The str/str<dot>lisp file

L
Lisp File, str.asd: The str<dot>asd file
Lisp File, str/str.lisp: The str/str<dot>lisp file

S
str.asd: The str<dot>asd file
str/str.lisp: The str/str<dot>lisp file

Jump to:   F   L   S  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   B   C   E   F   J   L   M   R   S   T   U   V   W  
Index Entry  Section

B
blank?: Exported functions
blankp: Exported functions

C
common-prefix: Exported functions
common-prefix-1: Internal functions
concat: Exported functions
contains?: Exported functions
containsp: Exported functions

E
empty?: Exported functions
emptyp: Exported functions
ends-with-p: Exported functions
ends-with?: Exported functions

F
from-file: Exported functions
Function, blank?: Exported functions
Function, blankp: Exported functions
Function, common-prefix: Exported functions
Function, common-prefix-1: Internal functions
Function, concat: Exported functions
Function, contains?: Exported functions
Function, containsp: Exported functions
Function, empty?: Exported functions
Function, emptyp: Exported functions
Function, ends-with-p: Exported functions
Function, ends-with?: Exported functions
Function, from-file: Exported functions
Function, join: Exported functions
Function, lines: Exported functions
Function, repeat: Exported functions
Function, replace-all: Exported functions
Function, split: Exported functions
Function, split-omit-nulls: Exported functions
Function, starts-with-p: Exported functions
Function, starts-with?: Exported functions
Function, substring: Exported functions
Function, to-file: Exported functions
Function, trim: Exported functions
Function, trim-left: Exported functions
Function, trim-right: Exported functions
Function, unlines: Exported functions
Function, unwords: Exported functions
Function, version: Exported functions
Function, words: Exported functions

J
join: Exported functions

L
lines: Exported functions

M
Macro, string-case: Exported macros

R
repeat: Exported functions
replace-all: Exported functions

S
split: Exported functions
split-omit-nulls: Exported functions
starts-with-p: Exported functions
starts-with?: Exported functions
string-case: Exported macros
substring: Exported functions

T
to-file: Exported functions
trim: Exported functions
trim-left: Exported functions
trim-right: Exported functions

U
unlines: Exported functions
unwords: Exported functions

V
version: Exported functions

W
words: Exported functions

Jump to:   B   C   E   F   J   L   M   R   S   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
S  
Index Entry  Section

*
*whitespaces*: Internal special variables

+
+version+: Exported special variables

S
Special Variable, *whitespaces*: Internal special variables
Special Variable, +version+: Exported special variables

Jump to:   *   +  
S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   P   S  
Index Entry  Section

P
Package, str: The str package

S
str: The str system
str: The str package
System, str: The str system

Jump to:   P   S