The vivid-diff Reference Manual

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 4.0 beta 2 "William Riker" on Thu Sep 15 06:29:37 2022 GMT+0.

Table of Contents


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


2 Systems

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


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

2.1 vivid-diff

Colored object diff viewer.

Author

SATO Shinichi

Source Control

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

Bug Tracker

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

License

MIT

Version

2.1.4

Dependencies
  • vivid-colors (system).
  • cl-colors2 (system).
  • closer-mop (system).
  • matrix-case (system).
Source

vivid-diff.asd.

Child Component

vivid-diff.lisp (file).


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   [Contents][Index]

3.1.1 vivid-diff/vivid-diff.asd

Source

vivid-diff.asd.

Parent Component

vivid-diff (system).

ASDF Systems

vivid-diff.


3.1.2 vivid-diff/vivid-diff.lisp

Source

vivid-diff.asd.

Parent Component

vivid-diff (system).

Packages

vivid-diff.

Public Interface
Internals

4 Packages

Packages are listed by definition order.


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

4.1 vivid-diff

Source

vivid-diff.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


5.1.1 Ordinary functions

Reader: 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.

Target Slot

origin.

Writer: (setf diff-comparable-origin) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Target Slot

origin.

Reader: 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.

Target Slot

object.

Writer: (setf diff-object) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Target Slot

object.

Function: diff-print (mismatched &optional output)
Package

vivid-diff.

Source

vivid-diff.lisp.

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.

Function: markup-nothing (object)
Package

vivid-diff.

Source

vivid-diff.lisp.


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.

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 :around (actual expected)
Method: mismatch-sexp (actual expected)

5.1.3 Standalone methods

Method: print-object ((object diff) output)
Source

vivid-diff.lisp.


5.1.4 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.

Direct superclasses

structure-object.

Direct subclasses
Direct methods

print-object.

Direct slots
Slot: object
Readers

diff-object.

Writers

(setf diff-object).

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.

Direct superclasses

diff.

Direct subclasses
Direct slots
Slot: origin
Readers

diff-comparable-origin.

Writers

(setf diff-comparable-origin).

Structure: nothing
Package

vivid-diff.

Source

vivid-diff.lisp.

Direct superclasses

diff.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *env*
Package

vivid-diff.

Source

vivid-diff.lisp.


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

5.2.2 Ordinary functions

Function: copy-diff (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: copy-diff-comparable (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: copy-hash-table-diff (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: copy-nothing (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: copy-object-diff (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: copy-pathname-diff (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: copy-string-diff (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: diff-comparable-object (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf diff-comparable-object) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: diff-comparable-p (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: diff-p (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: hash-table-diff-object (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf hash-table-diff-object) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: hash-table-diff-p (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: make-diff-comparable (&key object origin)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: markup-hash-table (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: markup-object (object origin)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: markup-pathname (object origin)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: markup-string (object origin)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: nothing-object (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf nothing-object) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: nothing-p (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: object-diff-object (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf object-diff-object) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: object-diff-origin (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf object-diff-origin) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: object-diff-p (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: pathname-diff-object (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf pathname-diff-object) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: pathname-diff-origin (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf pathname-diff-origin) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: pathname-diff-p (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: similar-vector-type-p (vec1 vec2)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: slots<=obj (obj)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: string-diff-object (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf string-diff-object) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: string-diff-origin (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: (setf string-diff-origin) (instance)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: string-diff-p (object)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: vprint-diff (output diff)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: vprint-hash-table-diff (output diff)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: vprint-nothing (output diff)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: vprint-object-diff (output diff)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: vprint-pathname-diff (output diff)
Package

vivid-diff.

Source

vivid-diff.lisp.

Function: vprint-string-diff (output diff)
Package

vivid-diff.

Source

vivid-diff.lisp.


5.2.3 Structures

Structure: hash-table-diff
Package

vivid-diff.

Source

vivid-diff.lisp.

Direct superclasses

diff.

Structure: object-diff
Package

vivid-diff.

Source

vivid-diff.lisp.

Direct superclasses

diff-comparable.

Structure: pathname-diff
Package

vivid-diff.

Source

vivid-diff.lisp.

Direct superclasses

diff-comparable.

Structure: string-diff
Package

vivid-diff.

Source

vivid-diff.lisp.

Direct superclasses

diff-comparable.


Appendix A Indexes


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

A.1 Concepts


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): Private ordinary functions
(setf diff-comparable-origin): Public ordinary functions
(setf diff-object): Public ordinary functions
(setf hash-table-diff-object): Private ordinary functions
(setf nothing-object): Private ordinary functions
(setf object-diff-object): Private ordinary functions
(setf object-diff-origin): Private ordinary functions
(setf pathname-diff-object): Private ordinary functions
(setf pathname-diff-origin): Private ordinary functions
(setf string-diff-object): Private ordinary functions
(setf string-diff-origin): Private ordinary functions

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

D
diff-comparable-object: Private ordinary functions
diff-comparable-origin: Public ordinary functions
diff-comparable-p: Private ordinary functions
diff-object: Public ordinary functions
diff-p: Private ordinary functions
diff-print: Public ordinary functions

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

G
Generic Function, mismatch-sexp: Public generic functions

H
hash-table-diff-object: Private ordinary functions
hash-table-diff-p: Private ordinary functions

M
make-diff-comparable: Private ordinary functions
markup: Public ordinary functions
markup-hash-table: Private ordinary functions
markup-nothing: Public ordinary functions
markup-object: Private ordinary functions
markup-pathname: Private ordinary functions
markup-string: Private ordinary functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, mismatch-sexp: Public generic functions
Method, print-object: Public standalone methods
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions
mismatch-sexp: Public generic functions

N
nothing-object: Private ordinary functions
nothing-p: Private ordinary functions

O
object-diff-object: Private ordinary functions
object-diff-origin: Private ordinary functions
object-diff-p: Private ordinary functions

P
pathname-diff-object: Private ordinary functions
pathname-diff-origin: Private ordinary functions
pathname-diff-p: Private ordinary functions
print-object: Public standalone methods

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

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

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