The vivid-diff Reference Manual

Table of Contents

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.

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

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

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

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

From developer

Product's goal

License

MIT

Developed with

SBCL

Tested with

• SBCL/2.1.7
• CCL/1.12.1
• ECL/21.2.1
• CLISP/2.49
• Allegro/10.1
• CMUCL/21D ; See below.
• ABCL/1.8.0

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.

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

• vivid-colors
• cl-colors2
• closer-mop
• matrix-case

Source

vivid-diff.asd (file)

Component

vivid-diff.lisp (file)

3 Files

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

3.1 Lisp

3.1.1 vivid-diff.asd

Location

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

Systems

vivid-diff (system)

3.1.2 vivid-diff/vivid-diff.lisp

Parent

vivid-diff (system)

Location

vivid-diff.lisp

Packages

vivid-diff

Exported Definitions

• diff (structure)
• diff-comparable (structure)
• diff-comparable-origin (function)
• (setf diff-comparable-origin) (function)
• diff-object (function)
• (setf diff-object) (function)
• diff-print (function)
• markup (function)
• markup-nothing (function)
• mismatch-sexp (generic function)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• nothing (structure)

Internal Definitions

• *env* (special variable)
• copy-diff (function)
• copy-diff-comparable (function)
• copy-hash-table-diff (function)
• copy-nothing (function)
• copy-object-diff (function)
• copy-pathname-diff (function)
• copy-string-diff (function)
• diff-comparable-object (function)
• (setf diff-comparable-object) (function)
• diff-comparable-p (function)
• diff-p (function)
• hash-table-diff (structure)
• hash-table-diff-object (function)
• (setf hash-table-diff-object) (function)
• hash-table-diff-p (function)
• make-diff-comparable (function)
• markup-hash-table (function)
• markup-object (function)
• markup-pathname (function)
• markup-string (function)
• nothing-object (function)
• (setf nothing-object) (function)
• nothing-p (function)
• object-diff (structure)
• object-diff-object (function)
• (setf object-diff-object) (function)
• object-diff-origin (function)
• (setf object-diff-origin) (function)
• object-diff-p (function)
• pathname-diff (structure)
• pathname-diff-object (function)
• (setf pathname-diff-object) (function)
• pathname-diff-origin (function)
• (setf pathname-diff-origin) (function)
• pathname-diff-p (function)
• similar-vector-type-p (function)
• slots<=obj (function)
• string-diff (structure)
• string-diff-object (function)
• (setf string-diff-object) (function)
• string-diff-origin (function)
• (setf string-diff-origin) (function)
• string-diff-p (function)
• vprint-diff (function)
• vprint-hash-table-diff (function)
• vprint-nothing (function)
• vprint-object-diff (function)
• vprint-pathname-diff (function)
• vprint-string-diff (function)

4 Packages

Packages are listed by definition order.

4.1 vivid-diff

Source

vivid-diff.lisp (file)

Use List

common-lisp

Exported Definitions

• diff (structure)
• diff-comparable (structure)
• diff-comparable-origin (function)
• (setf diff-comparable-origin) (function)
• diff-object (function)
• (setf diff-object) (function)
• diff-print (function)
• markup (function)
• markup-nothing (function)
• mismatch-sexp (generic function)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• mismatch-sexp (method)
• nothing (structure)

Internal Definitions

• *env* (special variable)
• copy-diff (function)
• copy-diff-comparable (function)
• copy-hash-table-diff (function)
• copy-nothing (function)
• copy-object-diff (function)
• copy-pathname-diff (function)
• copy-string-diff (function)
• diff-comparable-object (function)
• (setf diff-comparable-object) (function)
• diff-comparable-p (function)
• diff-p (function)
• hash-table-diff (structure)
• hash-table-diff-object (function)
• (setf hash-table-diff-object) (function)
• hash-table-diff-p (function)
• make-diff-comparable (function)
• markup-hash-table (function)
• markup-object (function)
• markup-pathname (function)
• markup-string (function)
• nothing-object (function)
• (setf nothing-object) (function)
• nothing-p (function)
• object-diff (structure)
• object-diff-object (function)
• (setf object-diff-object) (function)
• object-diff-origin (function)
• (setf object-diff-origin) (function)
• object-diff-p (function)
• pathname-diff (structure)
• pathname-diff-object (function)
• (setf pathname-diff-object) (function)
• pathname-diff-origin (function)
• (setf pathname-diff-origin) (function)
• pathname-diff-p (function)
• similar-vector-type-p (function)
• slots<=obj (function)
• string-diff (structure)
• string-diff-object (function)
• (setf string-diff-object) (function)
• string-diff-origin (function)
• (setf string-diff-origin) (function)
• string-diff-p (function)
• vprint-diff (function)
• vprint-hash-table-diff (function)
• vprint-nothing (function)
• vprint-object-diff (function)
• vprint-pathname-diff (function)
• vprint-string-diff (function)

5 Definitions

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

5.1 Exported definitions

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)

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

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

• diff-comparable (structure)
• hash-table-diff (structure)
• nothing (structure)

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

• string-diff (structure)
• pathname-diff (structure)
• object-diff (structure)

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)

5.2 Internal definitions

5.2.1 Special variables

Special Variable: *env*

Package

vivid-diff

Source

vivid-diff.lisp (file)

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)

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)

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types