NAME

Diffing_with_keys - When diffing lists where each element has a distinct key, we can refine the diffing patch by introducing two composite edit moves: swaps and moves.

Module

Module Diffing_with_keys

Documentation

Module Diffing_with_keys
: sig end

When diffing lists where each element has a distinct key, we can refine the diffing patch by introducing two composite edit moves: swaps and moves.

Swap s exchange the position of two elements. Swap cost is set to 2 * change - epsilon . Move s change the position of one element. Move cost is set to delete + addition - epsilon .

When the cost delete + addition is greater than change and with those specific weights, the optimal patch with Swap s and Move s can be computed directly and cheaply from the original optimal patch.

type 'a with_pos = {
pos : int ;
data : 'a ;
}

val with_pos : 'a list -> 'a with_pos list

type ('l, 'r, 'diff) mismatch =
| Name of {
pos : int ;
got : string ;
expected : string ;
types_match : bool ;
}
| Type of {
pos : int ;
got : 'l ;
expected : 'r ;
reason : 'diff ;
}

type ('l, 'r, 'diff) change =
| Change of ('l, 'r, 'diff) mismatch
| Swap of {
pos : int * int ;
first : string ;
last : string ;
}
| Move of {
name : string ;
got : int ;
expected : int ;
}
| Insert of {
pos : int ;
insert : 'r ;
}
| Delete of {
pos : int ;
delete : 'l ;
}

This specialized version of changes introduces two composite changes: Move and Swap

val prefix : Format.formatter -> ('l, 'r, 'diff) change -> unit

module Define : functor (D : sig end) -> sig end