Diffing_with_keys - When diffing lists where each element has a distinct key, we can refine the diffing

       Module Diffing_with_keys
        : sigend

       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'awith_pos = {
        pos : int ;
        data : 'a ;
        }

       valwith_pos : 'alist->'awith_poslisttype('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 Swapvalprefix : ('l,'r,'diff)changeFormat_doc.printermoduleDefine:(D:sigend)->sigend

OCamldoc                                           2025-06-12                              Diffing_with_keys(3o)

       Module   Diffing_with_keys

       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.