anchor.diff:          let mutable p = Unchecked.defaultof<_>
           pPU.U (d, r, &p)
           t <- asP.Create (&p)}
  +
  +  let pair (ePU: PUI<'e>) (rPU: PUI<'r>) =
  +    {new PUI<Pair<'e, 'r>> () with
  +       member pu.P (d, w, t) = ePU.P (d, w, &t.Elem); rPU.P (d, w, &t.Rest)
  +       member pu.U (d, r, t) = ePU.U (d, r, &t.Elem); rPU.U (d, r, &t.Rest)}
   
     type [<Bitwise; Rep>] PU () =
       inherit Rules ()
  
positive.code:       P ePU : PUP<'e, 'r, 'o, 't>
  
      static member Pair (P ePU: PUP<     'e     , Pair<'e, 'r>, 'o, 't>,
                          P rPU: PUP<         'r ,          'r , 'o, 't>)
                               : PUP<Pair<'e, 'r>, Pair<'e, 'r>, 'o, 't> =
        P {new PUI<Pair<'e, 'r>> () with
            member pu.P (d, w, t) = ePU.P (d, w, &t.Elem); rPU.P (d, w, &t.Rest)
            member pu.U (d, r, t) = ePU.U (d, r, &t.Elem); rPU.U (d, r, &t.Rest)}
  
      static member Tuple (_: Tuple<'t>,
                           asP: AsPairs<'p, 'o, 't>,
                           pPU: PUP<'p, 'p, 'o, 't>) = O <| asPairs asP pPU
  
      static member Record (tR: Record<'t>,
                            asP: AsPairs<'p, 'o, 't>,
  
negative.code:                     asP.Overwrite (tR, t, &p)}
  
      static member Case (c: Case<Empty, 'o, 't>) : PUS<Empty, 'o, 't> =
        S [case0 c]
  
      static member Case (c: Case<'p, 'o, 't>, P pPU: PUP<'p, 'p, 'o, 't>) =
        S [asPairs c pPU] : PUS<'p, 'o, 't>
  
      static member Choice (S pPU: PUS<       'p     , Choice<'p, 'o>, 't>,
  