# The diff-match-patch Reference Manual

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

# The diff-match-patch Reference Manual

This is the diff-match-patch Reference Manual, version 0.2.1, generated automatically by Declt version 2.3 "Robert April" on Tue Jan 09 14:29:01 2018 GMT+0.

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

## 1 Introduction

```This is a Common Lisp port of Neil Fraser's Diff, Match and Patch

It implements operations required for synchronizing sequences of Lisp
objects, in particular plain text represented as character strings.  The

1. Diff: Compare two sequences and return a list of differences (edit
operations).

Diff implements Gene Myers's 1986 algorithm with complexity O(N * D),
where N is the sum of lengths of the two sequences, and D is the size
of the shortest edit script.

2. Match: Given a search sequence, find a (possibly fuzzily) matching
subsequence of another sequence near a given position.

Match implements the Bitap algorithm, as described by Wu and Manber (1991).
Its broad idea is to search the space around the position first for an exact
occurence of the search pattern, then for a subsequence which matches the
pattern with one error, then with two errors, etc. If two or more matches
are found, they are compared by a score which trades off proximity and
number of errors.

3. Patch: Create a list of contextualized edit operation groups (“hunks”)
corresponding to a diff of two sequences A and B; apply it to a third
sequence A´ in order to produce an equivalent edit B´.

A hunk recording the changes of a subsequence S of A can be applied to a
subsequence S´ of A´ both when S and S´ are equal, and when S´ is a fuzzy
match of S in A´ near the position indicated by the hunk, and the badness of
the match (computed as the Levenshtein distance between S and S´ divided by
the length of S) is reasonably low.

The library defines the package DIFF-MATCH-PATH (nicknamed DMP), which
exports the following names:

{function} DIFF A B &KEY (TEST #'EQL)

Find the differences between two sequences A and B of elements comparable
under the function TEST. Return a list of edit operations of the form (OP
X), where OP is one of the keywords :+ :- :=, and X is a subsequence of A
or B.

{parameter} *DIFF-TIMEOUT*

Number of seconds to refine a diff before giving up (NIL for infinity).
Initial value = 5.0.

{parameter} *DIFF-EDIT-COST*

Cost of an empty edit operation in terms of edit characters. Used to
detect operationally trivial equalities when cleaning up diff lists.
Initial value = 4.

{parameter} *DIFF-CHECK-LINES-LENGTH*
When a diff is computed between strings, how long should they be to
to qualify for line-level-diff optimization. On strings whose length
is greater than this value, a line-level diff is run first to identify
the changed areas. NIL = don't optimize. Initial value = 1000.

{function} MAPDIFF FN DIFFS

Return a copy of edit operation list DIFFS in which the content of every
operation has been replaced by its image under FN.

{function} DIFF-ORIGIN DIFFS

Given a difference list, rebuild the first of the compared sequences.

{function} DIFF-DESTINATION DIFFS

Given a difference list, rebuild the second of the compared sequences.

{function} TRANSLATE-POSITION DIFFS POSITION

Given the difference list DIFFS between two sequences and a POSITION in
the first sequence, return the equivalent position in the second sequence.

{function} LEVENSHTEIN DIFFS

Given the difference list DIFFS between two sequences, return the
corresponding Levenshtein distance.

{function} INDEX-ABBREVIATOR &OPTIONAL (HASH-TABLE-TEST #'EQUAL)

Return two unary functions: one to abbreviate things to integers, the
other to restore them from integer abbreviations.

{function} MATCH SPACE PATTERN POSITION &KEY (TEST #'EQL)

Locate a subsequence most closely resembling PATTERN in SPACE near
POSITION.

{parameter} *MATCH-THRESHOLD*

At what point is no match declared (0.0 = perfection, 1.0 = very loose).
Initial value = 0.5.

{parameter} *MATCH-DISTANCE*

How far to search for a match (0 = exact location, 1000+ = broad match).
A match this many characters away from the expected location will add
1.0 to the error score (0.0 is a perfect match). Initial value = 1000.

{function} MAKE-PATCH A B &KEY (TEST #'EQL)
MAKE-PATCH &KEY DIFFS (TEST #'EQL)

When called with two seuqences A and B, compute the diff between them and
convert it into a list of hunk objects.  Alternatively, the diff can be
passed explicitly by keyword argument, and sequences reconstructed from
it.

{function} WRITE-CHARS-PATCH PATCH &OPTIONAL (OUT *STANDARD-OUTPUT*)

Write the formatted representation of the given PATCH (a hunk or list of
hunks, encoding a difference of character strings) to the stream OUT.

Read a formatted representation of patch encoding a difference of
character strings from the stream IN and return it as a list of hunks.

{function} WRITE-LINES-PATCH PATCH &OPTIONAL (OUT *STANDARD-OUTPUT*)

Write the formatted representation of the given PATCH (a hunk or list of
hunks, encoding a difference of line sequences) to the stream OUT.

{function} READ-LINES-PATCH &OPTIONAL (IN *STANDARD-INPUT*) (SEQ-TYPE 'VECTOR)

Read a formatted representation of patch encoding a difference of line
sequences from the stream IN and return it as a list of hunks.  The type
of line sequences in hunk difference lists is determined by the parameter
SEQ-TYPE (which normally should be one of the symbols VECTOR or LIST).

{class} HUNK
{accessor} HUNK-DIFFS HUNK
{accessor} HUNK-START-A HUNK
{accessor} HUNK-START-B HUNK
{accessor} HUNK-LENGTH-A HUNK
{accessor} HUNK-LENGTH-B HUNK

A wrapper for an edit or group of adjacent edits.

{function} APPLY-PATCH PATCH SEQ

Apply PATCH (a list of hunks) to the sequence SEQ.  Return two values:
(1) SEQ, or its modified copy; and (2) a list of booleans, of the same
length as PATCH, indicating for every hunk if it could be applied.

{parameter} *PATCH-DELETE-THRESHOLD*

When deleting a large block of text (over ~64 characters), how close do
the contents have to be to match the expected contents. (0.0 = perfection,
1.0 = very loose).  Note that *MATCH-THRESHOLD* controls how closely the
end points of a delete need to match. Initial value = 0.5.

{parameter} *PATCH-MARGIN*

Chunk size for context length. Initial value = 4.

{parameter} *MAX-BITS*

The number of bits in an int, used to limit the width of match patterns
when applying an inexact patch.Initial value = (INTEGER-LENGTH
MOST-POSITIVE-FIXNUM). Common Lisp having bigints allows to set this
value to NIL (meaning unlimited width), but keeping it as it is optimizes
performance by using fixints only.

```

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 diff-match-patch

Maintainer

Boris Smilga <boris.smilga@gmail.com>

Author

Neil Fraser; ported by Boris Smilga

Apache 2.0

Description

A Common Lisp port of Neil Fraser’s library of the same name

Version

0.2.1

Dependencies
• iterate
• cl-ppcre
Source

diff-match-patch.asd (file)

Component

src (module)

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

## 3 Modules

Modules are listed depth-first from the system components tree.

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

### 3.1 diff-match-patch/src

Parent

diff-match-patch (system)

Location

Components

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

## 4 Files

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

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

### 4.1 Lisp

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

#### 4.1.1 diff-match-patch.asd

Location

diff-match-patch.asd

Systems

diff-match-patch (system)

Packages

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

#### 4.1.2 diff-match-patch/src/package.lisp

Parent

src (module)

Location

package.lisp

Packages
Exported Definitions

#### 4.1.3 diff-match-patch/src/lib.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

lib.lisp

Internal Definitions

#### 4.1.4 diff-match-patch/src/diff.lisp

Dependency

lib.lisp (file)

Parent

src (module)

Location

diff.lisp

Exported Definitions
Internal Definitions

#### 4.1.5 diff-match-patch/src/cleanup.lisp

Dependency

diff.lisp (file)

Parent

src (module)

Location

cleanup.lisp

Internal Definitions

#### 4.1.6 diff-match-patch/src/match.lisp

Dependency

cleanup.lisp (file)

Parent

src (module)

Location

match.lisp

Exported Definitions

match (function)

Internal Definitions

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

#### 4.1.7 diff-match-patch/src/patch.lisp

Dependency

match.lisp (file)

Parent

src (module)

Location

patch.lisp

Exported Definitions
Internal Definitions

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

## 5 Packages

Packages are listed by definition order.

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

### 5.1 dmp-system

Source

diff-match-patch.asd

Use List
• uiop/package
• asdf/interface
• common-lisp

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

### 5.2 diff-match-patch

Source

package.lisp (file)

Nickname

dmp

Use List
• iterate
• common-lisp
Exported Definitions
Internal Definitions

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

## 6 Definitions

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

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

### 6.1 Exported definitions

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

#### 6.1.1 Special variables

Special Variable: *diff-check-lines-length*

When a diff is computed between strings, how long should they be to to qualify for line-level-diff optimization. On strings whose length is greater than this value, a line-level diff is run first to identify the changed areas. NIL = don’t optimize.

Package
Source

package.lisp (file)

Special Variable: *diff-edit-cost*

Cost of an empty edit operation in terms of edit characters. Used to detect operationally trivial equalities when cleaning up diff lists.

Package
Source

package.lisp (file)

Special Variable: *diff-timeout*

Number of seconds to refine a diff before giving up (NIL for infinity).

Package
Source

package.lisp (file)

Special Variable: *match-distance*

How far to search for a match (0 = exact location, 1000+ = broad match). A match this many characters away from the expected location will add 1.0 to the score (0.0 is a perfect match).

Package
Source

package.lisp (file)

Special Variable: *match-threshold*

At what point is no match declared (0.0 = perfection, 1.0 = very loose).

Package
Source

package.lisp (file)

Special Variable: *max-bits*

The number of bits in an int, used to limit the width of match patterns when applying an inexact patch. Common Lisp having bigints allows to set this value to NIL (meaning unlimited width), but keeping it as it is optimizes performance by using fixints only.

Package
Source

package.lisp (file)

Special Variable: *patch-delete-threshold*

When deleting a large block of text (over ~64 characters), how close do the contents have to be to match the expected contents. (0.0 = perfection, 1.0 = very loose). Note that *MATCH-THRESHOLD* controls how closely the end points of a delete need to match.

Package
Source

package.lisp (file)

Special Variable: *patch-margin*

Chunk size for context length.

Package
Source

package.lisp (file)

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

#### 6.1.2 Functions

Function: apply-patch PATCH SEQ &key PADDING TEST

Apply PATCH (a list of hunks) to the sequence SEQ. Return two values: (1) SEQ, or its modified copy; and (2) a list of booleans, of the same length as PATCH, indicating for every hunk if it could be applied.

Package
Source

patch.lisp (file)

Function: diff A B &key TEST

Find the differences between two sequences A and B of elements comparable under the function TEST. Return a list of edit operations of the form (OP X), where OP is one of the keywords :+ :- :=, and X is a subsequence of A or B.

Package
Source

diff.lisp (file)

Function: diff-destination DIFFS

Given a difference list, rebuild the second of the compared sequences.

Package
Source

diff.lisp (file)

Function: diff-origin DIFFS

Given a difference list, rebuild the first of the compared sequences.

Package
Source

diff.lisp (file)

Function: index-abbreviator &optional HASH-TABLE-TEST

Return two unary functions: one to abbreviate things to integers, the other to restore them from integer abbreviations.

Package
Source

diff.lisp (file)

Function: levenshtein DIFFS

Given the difference list DIFFS between two sequences, return the corresponding Levenshtein distance.

Package
Source

diff.lisp (file)

Function: make-patch &rest ARGS

When called with two seuqences A and B, compute the diff between them and convert it into a list of hunk objects. Alternatively, the diff can be passed explicitly by keyword argument, and sequences reconstructed from it.

Package
Source

patch.lisp (file)

Function: mapdiff FN DIFFS

Return a copy of edit operation list DIFFS in which the content of every operation has been replaced by its image under FN.

Package
Source

diff.lisp (file)

Function: match SPACE PATTERN POSITION &key TEST

Locate a subsequence most closely resembling PATTERN in SPACE near POSITION.

Package
Source

match.lisp (file)

Read a formatted representation of patch encoding a difference of character strings from the stream IN and return it as a list of hunks.

Package
Source

patch.lisp (file)

Read a formatted representation of patch encoding a difference of line sequences from the stream IN and return it as a list of hunks.

Package
Source

patch.lisp (file)

Function: translate-position DIFFS POSITION

Given the difference list DIFFS between two sequences and a POSITION in the first sequence, return the equivalent position in the second sequence.

Package
Source

diff.lisp (file)

Function: write-chars-patch PATCH &optional OUT

Write the formatted representation of the given PATCH (a hunk or list of hunks, encoding a difference of character strings) to the stream OUT.

Package
Source

patch.lisp (file)

Function: write-lines-patch PATCH &optional OUT

Write the formatted representation of the given PATCH (a hunk or list of hunks, encoding a difference of line sequences) to the stream OUT.

Package
Source

patch.lisp (file)

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

#### 6.1.3 Generic functions

Generic Function: hunk-diffs OBJECT
Generic Function: (setf hunk-diffs) NEW-VALUE OBJECT
Package
Methods
Method: hunk-diffs (HUNK hunk)

Source

patch.lisp (file)

Method: (setf hunk-diffs) NEW-VALUE (HUNK hunk)

automatically generated writer method

Source

patch.lisp (file)

Generic Function: hunk-length-a OBJECT
Generic Function: (setf hunk-length-a) NEW-VALUE OBJECT
Package
Methods
Method: hunk-length-a (HUNK hunk)

Source

patch.lisp (file)

Method: (setf hunk-length-a) NEW-VALUE (HUNK hunk)

automatically generated writer method

Source

patch.lisp (file)

Generic Function: hunk-length-b OBJECT
Generic Function: (setf hunk-length-b) NEW-VALUE OBJECT
Package
Methods
Method: hunk-length-b (HUNK hunk)

Source

patch.lisp (file)

Method: (setf hunk-length-b) NEW-VALUE (HUNK hunk)

automatically generated writer method

Source

patch.lisp (file)

Generic Function: hunk-start-a OBJECT
Generic Function: (setf hunk-start-a) NEW-VALUE OBJECT
Package
Methods
Method: hunk-start-a (HUNK hunk)

Source

patch.lisp (file)

Method: (setf hunk-start-a) NEW-VALUE (HUNK hunk)

automatically generated writer method

Source

patch.lisp (file)

Generic Function: hunk-start-b OBJECT
Generic Function: (setf hunk-start-b) NEW-VALUE OBJECT
Package
Methods
Method: hunk-start-b (HUNK hunk)

Source

patch.lisp (file)

Method: (setf hunk-start-b) NEW-VALUE (HUNK hunk)

automatically generated writer method

Source

patch.lisp (file)

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

#### 6.1.4 Classes

Class: hunk ()

A wrapper for an edit or group of adjacent edits.

Package
Source

patch.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: diffs
Type

list

Initargs

:diffs

hunk-diffs (generic function)

Writers

(setf hunk-diffs) (generic function)

Slot: start-a
Type

(integer 0)

Initargs

:start-a

hunk-start-a (generic function)

Writers

(setf hunk-start-a) (generic function)

Slot: start-b
Type

(integer 0)

Initargs

:start-b

hunk-start-b (generic function)

Writers

(setf hunk-start-b) (generic function)

Slot: length-a
Type

(integer 0)

Initargs

:length-a

hunk-length-a (generic function)

Writers

(setf hunk-length-a) (generic function)

Slot: length-b
Type

(integer 0)

Initargs

:length-b

hunk-length-b (generic function)

Writers

(setf hunk-length-b) (generic function)

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

### 6.2 Internal definitions

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

#### 6.2.1 Special variables

Package
Source

diff.lisp (file)

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

#### 6.2.2 Macros

Macro: dlet* BINDINGS &body BODY
Package
Source

lib.lisp (file)

Macro: with-diff-deadline (&optional TIMEOUT) &body BODY
Package
Source

diff.lisp (file)

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

#### 6.2.3 Functions

Return a copy of PATCH with PADDING added to its first and last hunk.

Package
Source

patch.lisp (file)

Function: affix-match A B TEST

If A and B are elementwise equal, return either of them. Otherwise, return four values: (1) the common prefix of A and B; (2, 3) the middle parts of A and B between the common prefix and the common suffix; and (4) the common suffix.

Package
Source

diff.lisp (file)

Function: apply-hunk HUNK SEQ DELTA TEST

Apply one HUNK to the sequence SEQ with an offset DELTA between expected and actual position. Return three values: (1) a boolean indicating if the hunk could be applied; (2) SEQ, or its modified copy; and (3) DELTA, possibly modified.

Package
Source

patch.lisp (file)

Function: cleanup-for-efficiency DIFFS TEST

Reduce the number of edits by eliminating operationally trivial equalities.

Package
Source

cleanup.lisp (file)

Function: cleanup-merge DIFFS TEST

Reorder and merge like edit sections in the list DIFFS. Merge equalities. Any edit section can move as long as it doesn’t cross an equality.

Package
Source

cleanup.lisp (file)

Function: cleanup-merge.join-differences DIFFS TEST

For every run of differences in the list DIFFS (separated by equalities), concatenate additions with additions and deletions with deletions to get two sequences, and factor out their common affixes, joining them unto the surrounding equalities.

Package
Source

cleanup.lisp (file)

Function: cleanup-merge.shift-differences DIFFS TEST

For every unpaired edit in the list DIFFS which is surrounded by equalities on both sides, try to eliminate either the left or the right equality by “shifting through” the edit. E. g. =A -BA =C is equivalent to -AB =AC, =A -BC =B is equivalent to =AB -CB.

Package
Source

cleanup.lisp (file)

Function: cleanup-semantic DIFFS TEST

Reduce the number of edits by eliminating semantically trivial equalities.

Package
Source

cleanup.lisp (file)

Function: cleanup-semantic.boundary-score STR POS &key START END

Compute a score from 6 to 0 determining to which extent the position POS in the portion of STR between START and END is a logical boundary.

Package
Source

cleanup.lisp (file)

Function: cleanup-semantic.eliminate-overlaps DIFFS TEST

Find overlaps between adjacent deletions and insertions in DIFFS and extract them by inserting equalities, provided the overlap is as big as the remainder of the edits. E. g. -ABCXXX +XXXDEF is the same as -ABC =XXX +DEF; -XXXABC +DEFXXX is the same as +DEF =XXX -ABC.

Package
Source

cleanup.lisp (file)

Function: cleanup-semantic.eliminate-short-equalities DIFFS

Eliminate every equality in DIFFS which is no longer than either all the deletions or all the insertions on its left side, and ditto for those on its right side, by replacing it with a delete-add pair.

Package
Source

cleanup.lisp (file)

Function: cleanup-semantic.next-short-equality DIFFS PREV-EQUALITIES

Find the first equality in DIFFS which is no longer than either all the deletions or all the insertions on its left side, and ditto for those on its right side. Return two values: (1) a three-element list, with (1a) differences on the left of the equality in reverse order, (1b) the content of the equality, and (1c) differences on the right in direct order; and (2) the list PREV-EQUALITIES unto which have been consed similar three-element lists representing equalities in DIFF before the one we’d found.

Package
Source

cleanup.lisp (file)

Function: cleanup-semantic.shift-lossless DIFFS TEST

For every unpaired edit in the list DIFFS which is surrounded by equalities on both sides, try to realign the edit by “shifting it through” to a logical boundary.

Package
Source

cleanup.lisp (file)

Function: copy-hunk HUNK &optional DIFFS START-A START-B LENGTH-A LENGTH-B

Return a copy of HUNK with zero or more slot values replaced by arguments.

Package
Source

patch.lisp (file)

Function: diff-bisect A B TEST

Use E. Myers’ (1986) algorithm to find the “middle snake” (equality) of an optimal diff of A and B, split the sequences just beyond the snake, and return four values: the two parts of A and the two parts of B. If the timeout is hit, or if the two sequences have no common elements, return NIL.

Package
Source

diff.lisp (file)

Function: diff-coerce DIFFS TYPE

Coerce the sequences in the elements of DIFFS to TYPE.

Package
Source

diff.lisp (file)

Function: diff-compute A B TEST

Find the differences between two sequences A and B of elements comparable under TEST, assuming that they don’t share a common preffix or suffix and that neither is empty.

Package
Source

diff.lisp (file)

Function: diff-line-mode A B TEST

Find the differences between the multiline texts A and B by comparing them as sequences of lines, then recursively comparing just the non-matching line runs by the general method.

Package
Source

diff.lisp (file)

Function: diff-seq-type DIFFS

Return the type of sequences in the elements of DIFFS.

Package
Source

diff.lisp (file)

Package
Source

cleanup.lisp (file)

Function: empty X
Package
Source

lib.lisp (file)

Function: filter-diffs DIFFS
Package
Source

cleanup.lisp (file)

Function: fn-to-hash-table-test FN
Package
Source

lib.lisp (file)

Package
Source

patch.lisp (file)

Function: get-internal-seconds ()
Package
Source

lib.lisp (file)

Function: half-match A B TEST

If the sequences A and B share a common infix which is at least half the length of the longer sequence, return five values: (1, 2) the prefixes of A and B up to (3) the common middle, and (4, 5) the suffixes of A and B after it. Otherwise, return NIL.

Package
Source

diff.lisp (file)

Function: index I L
Package
Source

lib.lisp (file)

Function: join PARTS
Package
Source

lib.lisp (file)

Function: join* &rest PARTS
Package
Source

lib.lisp (file)

Function: long-short A B
Package
Source

lib.lisp (file)

Package
Source

lib.lisp (file)

Function: make-hunk DIFFS START-A START-B LENGTH-A LENGTH-B CONTEXT

Create a hunk instance, ensuring that it includes a unique context.

Package
Source

patch.lisp (file)

Function: make-patch.cleanup DIFFS TEST

Cleanup DIFFS based on their size and type of elements.

Package
Source

patch.lisp (file)

Function: make-patch.next-hunk DIFFS START-A START-B LEFT-CONTEXT RIGHT-CONTEXT

Extract the next patch hunk from DIFFS.

Package
Source

patch.lisp (file)

Function: mapcall FN MFN &optional PARTS
Package
Source

lib.lisp (file)

Function: match-bitap SPACE PATTERN POSITION TEST

Use the Bitap algorithm to locate the best instance of PATTERN in SPACE near POSITION.

Package
Source

match.lisp (file)

Function: match-bitap.alphabet PATTERN TEST

Compute the alphabet for the Bitap algorithm, as a hash table mapping elements of PATTERN to integer hashes.

Package
Source

match.lisp (file)

Function: narrow SEQ START &optional END
Package
Source

lib.lisp (file)

Function: newline-char-p C
Package
Source

lib.lisp (file)

Function: next-diffs DIFFS

Extract all differences from the beginning of the list DIFFS, up to the first equality or the end of the list, whichever comes first. Return four values: (1) the concatenation of all deleted sequences, (2) the concatenation of all added sequences, (3) the equal sequence (or NIL if the end of DIFFS was reached), and (4) the rest of DIFFS after the equality.

Package
Source

diff.lisp (file)

Function: overlap A B &optional TEST
Package
Source

lib.lisp (file)

Package
Source

patch.lisp (file)

Package
Source

diff.lisp (file)

Function: prefixp A B &optional TEST
Package
Source

lib.lisp (file)

Package
Source

lib.lisp (file)

Package
Source

lib.lisp (file)

Function: revappend* X &rest YY
Package
Source

lib.lisp (file)

Function: seq-type X
Package
Source

lib.lisp (file)

Function: split-at SEQ POSITION &optional POSITION2 DROP-MIDDLE
Package
Source

lib.lisp (file)

Function: split-big-hunk HUNK SIZE

Split HUNK into pieces not exceeding SIZE and return them as a list of hunks.

Package
Source

patch.lisp (file)

Function: split-big-hunks PATCH

Return a copy of PATCH with all big hunks split. (Big hunks are hunks whose length exceeds the maximum limit of the match algorithm.)

Package
Source

patch.lisp (file)

Function: split-lines STR
Package
Source

lib.lisp (file)

Function: suffixp A B &optional TEST
Package
Source

lib.lisp (file)

Return a padding sequence for PATCH, of the given LENGTH.

Package
Source

patch.lisp (file)

Function: whitespace-char-p C
Package
Source

lib.lisp (file)

Function: write-char-urlencode C OUT
Package
Source

lib.lisp (file)

Function: write-line-urlencode LINE OUT
Package
Source

lib.lisp (file)

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

## Appendix A Indexes

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

### A.1 Concepts

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

### A.2 Functions

Jump to: (   A   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   W
Jump to: (   A   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   W

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