anchor.diff:      static member Case (case: Case<Empty, 'o, 't>) : PrettyS<Empty, 'o, 't> =
         S [doc (con (atxt case.Name))]
   
  -    static member Case (case: Case<'p, 'o, 't>,
  -                        P lsP: PrettyP<'p, 'p, 'o, 't>) : PrettyS<'p, 'o, 't> =
  -      let con = txt case.Name <^> line
  -      S [doc <| fun x ->
  -         let mutable ls = Unchecked.defaultof<_>
  -         case.Extract (x, &ls)
  -         part (gnest 2 (con <^> atomize (lsP.Pretty (&ls))))]
  +    static member Case (c: Case<'p, 'o, 't>, P lsP: PrettyP<'p, 'p, 'o, 't>) =
  +      S [case c.Name c lsP] : PrettyS<'p, 'o, 't>
   
       static member Choice (S pP: PrettyS<       'p,      Choice<'p, 'o>, 't>,
                             S oP: PrettyS<           'o ,            'o , 't>) =
  
positive.code:            |> gnest i
             |> enclose (o, c)
             |> atom}
  
    type [<Rep; Integral>] Pretty () =
      inherit Rules ()
  
negative.code:       P eP : PrettyP<'e, 'r, 't, 't>
  
      static member Labelled (l: Labelled<'e, 'r, 'o, 't>, O eP: PrettyO<'e>) =
        P (labelled l.Name l.Index eP) : PrettyP<'e, 'r, 'o, 't>
  
      static member Pair (P eP: PrettyP<     'e,      Pair<'e, 'r>, 'o, 't>,
                          P rP: PrettyP<         'r ,          'r , 'o, 't>) =
        let sep = if FSharpType.IsRecord typeof<'t> then semiLine else commaLine
        P (pair sep eP rP)    : PrettyP<Pair<'e, 'r>, Pair<'e, 'r>, 'o, 't>
  
      static member Product (asP: AsPairs<'p,'t,'t>, P pP: PrettyP<'p,'p,'t,'t>) =
        let lr = if FSharpType.IsRecord typeof<'t> then lrbrace else lrparen
  