The vivid-diff Reference Manual

Table of Contents

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

The vivid-diff Reference Manual

This is the vivid-diff Reference Manual, version 2.1.4, generated automatically by Declt version 3.0 "Montgomery Scott" on Sun May 15 06:26:31 2022 GMT+0.


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

1 Introduction

VIVID-DIFF 2.0.0

What is this?

Colored object diff viewer.

Intended to be used in the test frameworks.

Alternatives and differences.

| name | target | output | patch | | ---------------------- | ----------- | ---------- | ----- | | cl-difflib | sequence | unix-style | * | | clos-diff | clos-object | list | * | | monkeylib-prose-diff | text-file | html | | | diff | text-file | unix-style | | | diff-match-patch | sequence | list | * | | vivid-diff | any object | colored | |

Usage

(let ((expected '(:a :b :c))
      (actual '(:a "b" :c)))
  (diff-print (mismatch-sexp actual expected)))

image of the conses diff.

(let ((expected "Common Lisp is awesome!!")
      (actual   "Common lisp is awesome!!"))
  (diff-print (mismatch-sexp actual expected)))

image of the string diff.

(let ((expected (alexandria:plist-hash-table '(:a "a" :b "b" :c "c")))
      (actual (alexandria:plist-hash-table '(:b :b :c "c" :d "d"))))
  (diff-print (mismatch-sexp actual expected)))

image of the hash-table diff.

As the name shows, MISMATCH-SEXP is for S-Expression, i.e. macroexpanded form. Please note about uninterned symbols are treated as the same as expected. (In corner cases, this behavior may be the pitfall though.)

(let ((expected (macroexpand-1 '(with-open-file (s "path") (read s))))
      (actual (macroexpand-1 '(with-open-file (out "path") (read out)))))
  (diff-print (mismatch-sexp actual expected)))

image of the macroexpanded diff.

From developer

Product's goal

License

MIT

Developed with

SBCL

Tested with

Known issue

CMUCL

CMUCL pass the test of vivid-diff but vivid-colors that vivid-diff depends on does not support CMUCL.

Installation


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 vivid-diff

Author

SATO Shinichi

Source Control

(:git "git@github.com:hyotang666/vivid-diff")

Bug Tracker

https://github.com/hyotang666/vivid-diff/issues

License

MIT

Description

Colored object diff viewer.

Version

2.1.4

Dependencies
Source

vivid-diff.asd (file)

Component

vivid-diff.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 vivid-diff.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/vivid-diff-20220220-git/vivid-diff.asd

Systems

vivid-diff (system)


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

3.1.2 vivid-diff/vivid-diff.lisp

Parent

vivid-diff (system)

Location

vivid-diff.lisp

Packages

vivid-diff

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 vivid-diff

Source

vivid-diff.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 Functions

Function: diff-comparable-origin INSTANCE

# DIFF-COMPARABLE-ORIGIN

## Description:

### syntax (DIFF-COMPARABLE-ORIGIN sb-kernel:instance)
=> result
### setf
(SETF (DIFF-COMPARABLE-ORIGIN SB-KERNEL:INSTANCE) SB-KERNEL::VALUE) => new-value

## Arguments and Values:
instance := DIFF-COMPARABLE
result := T

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

vivid-diff

Source

vivid-diff.lisp (file)

Writer

(setf diff-comparable-origin) (function)

Function: (setf diff-comparable-origin) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Reader

diff-comparable-origin (function)

Function: diff-object INSTANCE

# DIFF-OBJECT

## Description:
Accessor for DIFF.

### syntax (DIFF-OBJECT sb-kernel:instance)
=> result
### setf
(SETF (DIFF-OBJECT SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := DIFF, otherwise implementation dependent condition.

“‘lisp
#?(diff-object "not diff object")
:signals condition
“‘
result := T

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

vivid-diff

Source

vivid-diff.lisp (file)

Writer

(setf diff-object) (function)

Function: (setf diff-object) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Reader

diff-object (function)

Function: diff-print MISMATCHED &optional OUTPUT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: markup OBJECT

# MARKUP

## Description:
Markup OBJECT as DIFF.

### syntax (MARKUP object)
=> result

## Arguments and Values:
object := T
result := DIFF.

## Affected By:
none

## Side-Effects:
none

## Notes:
When *PRINT-READABLY* and *PRINT-ESCAPSE* is NIL and VIVID-COLORS:*PRINT-VIVID* is T, and VIVID-COLORS:*VPRINT-DISPATCH* bound by :vivid-diff dispatch-table,
Colored notation is printed.

“‘lisp
#?(let ((vivid-colors:*print-vivid* t)
(vivid-colors:*vprint-dispatch* (vivid-colors:find-vprint-dispatch :vivid-diff))) (write (markup 0) :readably nil :escape nil))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "0"))
“‘

## Exceptional-Situations:

Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: markup-nothing OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)


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

5.1.2 Generic functions

Generic Function: mismatch-sexp ACTUAL EXPECTED

# MISMATCH-SEXP

## Description:
If S-Expression is mismatch, DIFF object is returned,
otherwise actual is returned.

### syntax (MISMATCH-SEXP actual expected)
=> result

## Argument Precedence Order:
actual expected

## Method signature:
* MISMATCH-SEXP (ACTUAL HASH-TABLE) (EXPECTED HASH-TABLE))
* MISMATCH-SEXP (ACTUAL STANDARD-OBJECT) (EXPECTED STANDARD-OBJECT))
* MISMATCH-SEXP (ACTUAL STRUCTURE-OBJECT) (EXPECTED STRUCTURE-OBJECT))
* MISMATCH-SEXP (ACTUAL ARRAY) (EXPECTED ARRAY))
* MISMATCH-SEXP (ACTUAL VECTOR) (EXPECTED VECTOR))
* MISMATCH-SEXP (ACTUAL BIT-VECTOR) (EXPECTED BIT-VECTOR))
* MISMATCH-SEXP (ACTUAL NUMBER) (EXPECTED NUMBER))
* MISMATCH-SEXP (ACTUAL PATHNAME) (EXPECTED PATHNAME))
* MISMATCH-SEXP (ACTUAL STRING) (EXPECTED STRING))
* MISMATCH-SEXP (ACTUAL LIST) (EXPECTED LIST))
* MISMATCH-SEXP (ACTUAL SYMBOL) (EXPECTED SYMBOL))
* MISMATCH-SEXP :AROUND (ACTUAL T) (EXPECTED T))
* MISMATCH-SEXP (ACTUAL T) (EXPECTED T))

## Arguments and Values:
actual := T
expected := T
result := (or T DIFF)

## Affected By:
none

## Side-Effects:
none

## Notes:
As the name explains, MISMATCH-SEXP is for S-Expression.
i.e. macro expansion form especially uninterned symbol.

“‘lisp
#?(mismatch-sexp ’#:a ’#:b)
:satisfies (lambda (x)
(& (symbolp x)
(null (symbol-package x))
(equal "A" (symbol-name x))))
“‘

“‘lisp
#?(let ((expanded-form1 (macroexpand-1 #0=’(case 0)))
(expanded-form2 (macroexpand-1 #0#)))
(values (tree-equal expanded-form1 expanded-form2)
(tree-equal expanded-form1 (mismatch-sexp expanded-form1 expanded-form2)))) :values (nil t)
“‘

## Exceptional-Situations:

#### Numbers

“‘lisp
#?(mismatch-sexp 0 0)
=> 0
“‘

“‘lisp
#?(mismatch-sexp 0 1)
:be-the diff
“‘

“‘lisp
#?(diff-print (mismatch-sexp 0 1))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "0"))
“‘

#### Characters

“‘lisp
#?(mismatch-sexp #\a #\b)
:be-the diff
“‘

“‘lisp
#?(diff-print (mismatch-sexp #\a #\b))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red (prin1-to-string #\a)))
“‘

#### Symbols

“‘lisp
#?(mismatch-sexp t t)
=> T
“‘

“‘lisp
#?(mismatch-sexp t nil)
:be-the diff
“‘

“‘lisp
#?(diff-print (mismatch-sexp t nil))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "T"))
“‘

“‘lisp
#?(mismatch-sexp :key nil)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":KEY")))))
“‘

“‘lisp
#?(mismatch-sexp :key ’#:uninterned)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":KEY")))))
“‘

#### List

“‘lisp
#?(mismatch-sexp ’(:a) ’(:a))
=> (:A)
, :test
“‘

“‘lisp
#?(mismatch-sexp ’(:a) ’(:b))
:satisfies (lambda (diff)
(& (typep diff ’(cons diff null))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "(~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red (prin1-to-string ’:a)))))))
“‘
Dot list.

“‘lisp
#?(mismatch-sexp ’(a) ’(a . b))
:satisfies (lambda (diff)
(& (typep diff ’(cons (eql a) diff))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "(A . ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "NIL"))))))
“‘
Lesser

“‘lisp
#?(mismatch-sexp ’(a) ’(a b))
:satisfies (lambda (diff)
(& (typep diff ’(cons (eql a) diff))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "(A . ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "NIL"))))))
“‘
Greater

“‘lisp
#?(mismatch-sexp ’(a b) ’(a))
:satisfies (lambda (diff)
(& (typep diff ’(cons (eql a) diff))
(let ((output (with-output-to-string (out) (diff-print diff out))))
(& (equal "(A . (B))" (ppcre:regex-replace-all "\\x1B[^m]+m" output ""))
(let ((red-escape-sequence
(search (let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:make-color-string cl-colors2:+red+))
output)))
(& (< red-escape-sequence
(search cl-ansi-text:+reset-color-string+ output))))))))
“‘

#### String

“‘lisp
#?(mismatch-sexp "a" "a")
=> "a"
, :test
“‘

“‘lisp
#?(mismatch-sexp "a" "b")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "\"~A\""
(cl-ansi-text:red "a" :style :background)))))
“‘
Lesser

“‘lisp
#?(mismatch-sexp "a" "ab")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "\"a~A\""
(cl-ansi-text:red ":NULL" :effect :blink)))))
“‘
Greater

“‘lisp
#?(mismatch-sexp "ab" "a")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "\"a~A\""
(cl-ansi-text:red "b" :style :background)))))
“‘

#### Pathname

“‘lisp
#?(mismatch-sexp #P"hoge" #P"hoge")
=> #P"hoge"
, :test
“‘

“‘lisp
#?(mismatch-sexp #P"hoge" #P"fuga")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#P\"~A\""
(cl-ansi-text:red "hoge" :style :background)))))
“‘

#### Bit-vector

“‘lisp
#?(mismatch-sexp #*1101 #*1101)
=> #*1101
, :test
“‘

“‘lisp
#?(mismatch-sexp #*1101 #*1111)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "#*1101")))))
“‘

#### Vector

“‘lisp
#?(mismatch-sexp #() #())
=> #()
, :test
“‘
type mismatch.

“‘lisp
#?(mismatch-sexp "a" #(#\a))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "\"a\"")))))
“‘
element mismatch.

“‘lisp
#?(mismatch-sexp #(hoge) #(#\a))
:satisfies (lambda (diff)
(& (typep diff ’(vector t *))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#(~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "HOGE"))))))
“‘
Lesser

“‘lisp
#?(mismatch-sexp #(a) #(a b))
:satisfies (lambda (diff)
(& (typep diff ’(vector t *))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#(A ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":NULL" :effect :blink))))))
“‘
Greater

“‘lisp
#?(mismatch-sexp #(a b) #(a))
:satisfies (lambda (diff)
(& (typep diff ’(vector t *))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#(A ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "B"))))))
“‘

#### Array

“‘lisp
#?(mismatch-sexp #0A() #0A())
=> #0A()
, :test
“‘
dimension mismatch

“‘lisp
#?(mismatch-sexp #0A() #1A())
:satisfies (lambda (diff)
(& (typep diff ’diff)
(let ((output (with-output-to-string (out) (diff-print diff out))))
(& (uiop:string-prefix-p (let ((cl-ansi-text:*color-mode* :8bit)) (cl-ansi-text:make-color-string cl-colors2:+red+))
output)
(uiop:string-suffix-p output cl-ansi-text:+reset-color-string+)
(equal "(:DIFFERENT-DIMENSIONS :EXPECTED (0) :ACTUAL NIL #0ANIL)" (ppcre:regex-replace-all "\\x1B[^m]+m" output ""))))))
“‘
Lesser

“‘lisp
#?(mismatch-sexp #2A((a b)) #2A((a b) (c d)))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(let ((output (with-output-to-string (out) (diff-print diff out))))
(& (uiop:string-prefix-p (let ((cl-ansi-text:*color-mode* :8bit)) (cl-ansi-text:make-color-string cl-colors2:+red+))
output)
(uiop:string-suffix-p output cl-ansi-text:+reset-color-string+)
(equal "(:DIFFERENT-DIMENSIONS :EXPECTED (2 2) :ACTUAL (1 2) #2A((A B)))" (ppcre:regex-replace-all "\\x1B[^m]+m" output ""))))))
“‘

“‘lisp
#?(mismatch-sexp #2A((a b)) #2A((a c)))
:satisfies (lambda (diff)
(& (typep diff ’array)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#2A((A ~A))"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "B"))))))
“‘

#### Strucuture

“‘lisp
#?(mismatch-sexp cl-colors2:+red+ cl-colors2:+red+)
=> #.cl-colors2:+red+
, :test
“‘

“‘lisp
#?(mismatch-sexp cl-colors2:+red+ cl-colors2:+blue+)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#S(CL-COLORS2:RGB :RED ~A :GREEN 0 :BLUE ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "1"))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "0"))))))
“‘

#### Standard-object

“‘lisp
#?(defclass c () ((slot :initarg :slot)))
:be-the standard-class
“‘

“‘lisp
#?(mismatch-sexp (make-instance ’c :slot :a) (make-instance ’c :slot :a))
:satisfies (lambda (result)
(& (typep result ’c)
(equal :a (slot-value result ’slot))))
“‘
Not bound.

“‘lisp
#?(mismatch-sexp (make-instance ’c) (make-instance ’c :slot :a))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<C :SLOT ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":UNBOUND" :effect :blink))))))
“‘
Should be unbound.

“‘lisp
#?(mismatch-sexp (make-instance ’c :slot :a) (make-instance ’c))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<C :SLOT ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":A"))))))
“‘
Mismatch value.

“‘lisp
#?(mismatch-sexp (make-instance ’c :slot :a) (make-instance ’c :slot :b))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<C :SLOT ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":A"))))))
“‘

#### Hash-table

“‘lisp
#?(mismatch-sexp (make-hash-table) (make-hash-table))
:equivalents (make-hash-table)
, :test
“‘
Lesser

“‘lisp
#?(mismatch-sexp (make-hash-table) (alexandria:plist-hash-table ’(:a :b)))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<HASH-TABLE :A ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":MISSING" :effect :blink))))))
“‘
Greater

“‘lisp
#?(mismatch-sexp (alexandria:plist-hash-table ’(:a :b)) (make-hash-table))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<HASH-TABLE :A ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":B"))))))
“‘
Mismatch value.

“‘lisp
#?(mismatch-sexp (alexandria:plist-hash-table ’(:a :b)) (alexandria:plist-hash-table ’(:a "b"))) :satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<HASH-TABLE :A ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":B"))))))
“‘

Package

vivid-diff

Source

vivid-diff.lisp (file)

Methods
Method: mismatch-sexp (ACTUAL hash-table) (EXPECTED hash-table)
Method: mismatch-sexp (ACTUAL standard-object) (EXPECTED standard-object)
Method: mismatch-sexp (ACTUAL structure-object) (EXPECTED structure-object)
Method: mismatch-sexp (ACTUAL array) (EXPECTED array)
Method: mismatch-sexp (ACTUAL vector) (EXPECTED vector)
Method: mismatch-sexp (ACTUAL bit-vector) (EXPECTED bit-vector)
Method: mismatch-sexp (ACTUAL number) (EXPECTED number)
Method: mismatch-sexp (ACTUAL pathname) (EXPECTED pathname)
Method: mismatch-sexp (ACTUAL string) (EXPECTED string)
Method: mismatch-sexp (ACTUAL list) (EXPECTED list)
Method: mismatch-sexp (ACTUAL symbol) (EXPECTED symbol)
Method: mismatch-sexp ACTUAL EXPECTED around
Method: mismatch-sexp ACTUAL EXPECTED

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

5.1.3 Structures

Structure: diff ()

# DIFF

## Description:
Abstract structure for every DIFF object.

## Class Precedence List: (case in SBCL) diff structure-object slot-object t

## Effective Slots:
OBJECT [Type] T

## Notes:

Package

vivid-diff

Source

vivid-diff.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods

print-object (method)

Direct slots
Slot: object
Readers

diff-object (function)

Writers

(setf diff-object) (function)

Structure: diff-comparable ()

# DIFF-COMPARABLE

## Description:
Abstract diff structure for comparables.

## Class Precedence List: (case in SBCL) diff-comparable diff structure-object slot-object t

## Effective Slots:
ORIGIN [Type] T
OBJECT [Type] T

## Notes:

Package

vivid-diff

Source

vivid-diff.lisp (file)

Direct superclasses

diff (structure)

Direct subclasses
Direct slots
Slot: origin
Readers

diff-comparable-origin (function)

Writers

(setf diff-comparable-origin) (function)

Structure: nothing ()
Package

vivid-diff

Source

vivid-diff.lisp (file)

Direct superclasses

diff (structure)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *env*
Package

vivid-diff

Source

vivid-diff.lisp (file)


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

5.2.2 Functions

Function: copy-diff INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: copy-diff-comparable INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: copy-hash-table-diff INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: copy-nothing INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: copy-object-diff INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: copy-pathname-diff INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: copy-string-diff INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: diff-comparable-object INSTANCE
Function: (setf diff-comparable-object) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: diff-comparable-p OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: diff-p OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: hash-table-diff-object INSTANCE
Function: (setf hash-table-diff-object) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: hash-table-diff-p OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: make-diff-comparable &key (OBJECT OBJECT) (ORIGIN ORIGIN)
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: markup-hash-table OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: markup-object OBJECT ORIGIN
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: markup-pathname OBJECT ORIGIN
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: markup-string OBJECT ORIGIN
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: nothing-object INSTANCE
Function: (setf nothing-object) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: nothing-p OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: object-diff-object INSTANCE
Function: (setf object-diff-object) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: object-diff-origin INSTANCE
Function: (setf object-diff-origin) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: object-diff-p OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: pathname-diff-object INSTANCE
Function: (setf pathname-diff-object) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: pathname-diff-origin INSTANCE
Function: (setf pathname-diff-origin) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: pathname-diff-p OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: similar-vector-type-p VEC1 VEC2
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: slots<=obj OBJ
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: string-diff-object INSTANCE
Function: (setf string-diff-object) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: string-diff-origin INSTANCE
Function: (setf string-diff-origin) VALUE INSTANCE
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: string-diff-p OBJECT
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: vprint-diff OUTPUT DIFF
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: vprint-hash-table-diff OUTPUT DIFF
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: vprint-nothing OUTPUT DIFF
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: vprint-object-diff OUTPUT DIFF
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: vprint-pathname-diff OUTPUT DIFF
Package

vivid-diff

Source

vivid-diff.lisp (file)

Function: vprint-string-diff OUTPUT DIFF
Package

vivid-diff

Source

vivid-diff.lisp (file)


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

5.2.3 Structures

Structure: hash-table-diff ()
Package

vivid-diff

Source

vivid-diff.lisp (file)

Direct superclasses

diff (structure)

Structure: object-diff ()
Package

vivid-diff

Source

vivid-diff.lisp (file)

Direct superclasses

diff-comparable (structure)

Structure: pathname-diff ()
Package

vivid-diff

Source

vivid-diff.lisp (file)

Direct superclasses

diff-comparable (structure)

Structure: string-diff ()
Package

vivid-diff

Source

vivid-diff.lisp (file)

Direct superclasses

diff-comparable (structure)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   V  
Index Entry  Section

F
File, Lisp, vivid-diff.asd: The vivid-diff․asd file
File, Lisp, vivid-diff/vivid-diff.lisp: The vivid-diff/vivid-diff․lisp file

L
Lisp File, vivid-diff.asd: The vivid-diff․asd file
Lisp File, vivid-diff/vivid-diff.lisp: The vivid-diff/vivid-diff․lisp file

V
vivid-diff.asd: The vivid-diff․asd file
vivid-diff/vivid-diff.lisp: The vivid-diff/vivid-diff․lisp file

Jump to:   F   L   V  

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

A.2 Functions

Jump to:   (  
C   D   F   G   H   M   N   O   P   S   V  
Index Entry  Section

(
(setf diff-comparable-object): Internal functions
(setf diff-comparable-origin): Exported functions
(setf diff-object): Exported functions
(setf hash-table-diff-object): Internal functions
(setf nothing-object): Internal functions
(setf object-diff-object): Internal functions
(setf object-diff-origin): Internal functions
(setf pathname-diff-object): Internal functions
(setf pathname-diff-origin): Internal functions
(setf string-diff-object): Internal functions
(setf string-diff-origin): Internal functions

C
copy-diff: Internal functions
copy-diff-comparable: Internal functions
copy-hash-table-diff: Internal functions
copy-nothing: Internal functions
copy-object-diff: Internal functions
copy-pathname-diff: Internal functions
copy-string-diff: Internal functions

D
diff-comparable-object: Internal functions
diff-comparable-origin: Exported functions
diff-comparable-p: Internal functions
diff-object: Exported functions
diff-p: Internal functions
diff-print: Exported functions

F
Function, (setf diff-comparable-object): Internal functions
Function, (setf diff-comparable-origin): Exported functions
Function, (setf diff-object): Exported functions
Function, (setf hash-table-diff-object): Internal functions
Function, (setf nothing-object): Internal functions
Function, (setf object-diff-object): Internal functions
Function, (setf object-diff-origin): Internal functions
Function, (setf pathname-diff-object): Internal functions
Function, (setf pathname-diff-origin): Internal functions
Function, (setf string-diff-object): Internal functions
Function, (setf string-diff-origin): Internal functions
Function, copy-diff: Internal functions
Function, copy-diff-comparable: Internal functions
Function, copy-hash-table-diff: Internal functions
Function, copy-nothing: Internal functions
Function, copy-object-diff: Internal functions
Function, copy-pathname-diff: Internal functions
Function, copy-string-diff: Internal functions
Function, diff-comparable-object: Internal functions
Function, diff-comparable-origin: Exported functions
Function, diff-comparable-p: Internal functions
Function, diff-object: Exported functions
Function, diff-p: Internal functions
Function, diff-print: Exported functions
Function, hash-table-diff-object: Internal functions
Function, hash-table-diff-p: Internal functions
Function, make-diff-comparable: Internal functions
Function, markup: Exported functions
Function, markup-hash-table: Internal functions
Function, markup-nothing: Exported functions
Function, markup-object: Internal functions
Function, markup-pathname: Internal functions
Function, markup-string: Internal functions
Function, nothing-object: Internal functions
Function, nothing-p: Internal functions
Function, object-diff-object: Internal functions
Function, object-diff-origin: Internal functions
Function, object-diff-p: Internal functions
Function, pathname-diff-object: Internal functions
Function, pathname-diff-origin: Internal functions
Function, pathname-diff-p: Internal functions
Function, similar-vector-type-p: Internal functions
Function, slots<=obj: Internal functions
Function, string-diff-object: Internal functions
Function, string-diff-origin: Internal functions
Function, string-diff-p: Internal functions
Function, vprint-diff: Internal functions
Function, vprint-hash-table-diff: Internal functions
Function, vprint-nothing: Internal functions
Function, vprint-object-diff: Internal functions
Function, vprint-pathname-diff: Internal functions
Function, vprint-string-diff: Internal functions

G
Generic Function, mismatch-sexp: Exported generic functions

H
hash-table-diff-object: Internal functions
hash-table-diff-p: Internal functions

M
make-diff-comparable: Internal functions
markup: Exported functions
markup-hash-table: Internal functions
markup-nothing: Exported functions
markup-object: Internal functions
markup-pathname: Internal functions
markup-string: Internal functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
Method, mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions
mismatch-sexp: Exported generic functions

N
nothing-object: Internal functions
nothing-p: Internal functions

O
object-diff-object: Internal functions
object-diff-origin: Internal functions
object-diff-p: Internal functions

P
pathname-diff-object: Internal functions
pathname-diff-origin: Internal functions
pathname-diff-p: Internal functions

S
similar-vector-type-p: Internal functions
slots<=obj: Internal functions
string-diff-object: Internal functions
string-diff-origin: Internal functions
string-diff-p: Internal functions

V
vprint-diff: Internal functions
vprint-hash-table-diff: Internal functions
vprint-nothing: Internal functions
vprint-object-diff: Internal functions
vprint-pathname-diff: Internal functions
vprint-string-diff: Internal functions

Jump to:   (  
C   D   F   G   H   M   N   O   P   S   V  

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

A.3 Variables

Jump to:   *  
O   S  
Index Entry  Section

*
*env*: Internal special variables

O
object: Exported structures
origin: Exported structures

S
Slot, object: Exported structures
Slot, origin: Exported structures
Special Variable, *env*: Internal special variables

Jump to:   *  
O   S  

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

A.4 Data types

Jump to:   D   H   N   O   P   S   V  
Index Entry  Section

D
diff: Exported structures
diff-comparable: Exported structures

H
hash-table-diff: Internal structures

N
nothing: Exported structures

O
object-diff: Internal structures

P
Package, vivid-diff: The vivid-diff package
pathname-diff: Internal structures

S
string-diff: Internal structures
Structure, diff: Exported structures
Structure, diff-comparable: Exported structures
Structure, hash-table-diff: Internal structures
Structure, nothing: Exported structures
Structure, object-diff: Internal structures
Structure, pathname-diff: Internal structures
Structure, string-diff: Internal structures
System, vivid-diff: The vivid-diff system

V
vivid-diff: The vivid-diff system
vivid-diff: The vivid-diff package

Jump to:   D   H   N   O   P   S   V