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