anchor.diff:                      asP.Overwrite (tR, t, &p)}
   
       static member Case (c: Case<Empty, 'o, 't>) : PUS<Empty, 'o, 't> =
  -      S [prim (fun _ -> c.OfPairs Unchecked.defaultof<_>) (fun _ _ -> ())]
  +      S [case0 c]
   
  -    static member Case (c: Case<'p, 'o, 't>, pPU: PUP<'p, 'p, 'o, 't>) =
  +    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>,
  
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:         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 ()
  