anchor.diff:  
   type [<AbstractClass>] ProductUp<'w, 'l, 'h, 'r> () =
     inherit Up<'w, 'h> ()
  -  [<DefaultValue>] val mutable L: 'l
  -  [<DefaultValue>] val mutable R: 'r
  +  [<DefaultValue>] val mutable internal L: 'l
  +  [<DefaultValue>] val mutable internal R: 'r
   
   type [<AbstractClass>] Down<'w, 'h> () =
     abstract DownFirst: Up<'w, 'h> * 'h -> option<Zipper<'w>>
     abstract DownLast: Up<'w, 'h> * 'h -> option<Zipper<'w>>
   
  -type [<AbstractClass;AllowNullLiteral>] ProductDown<'w, 'l, 'h, 'r, 'sp, 'c, 'p, 't> () =
  +type [<AbstractClass;AllowNullLiteral>] ProductDownBase<'w, 'c, 'p, 't> () =
  +  [<DefaultValue>] val mutable internal L: ProductDownBase<'w, 'c, 'p, 't>
  +  [<DefaultValue>] val mutable internal R: ProductDownBase<'w, 'c, 'p, 't>
     abstract Down: Up<'w, 't> * AsProduct<'p, 't> * byref<'p> -> Zipper<'w>
  +
  +type [<AbstractClass>] ProductDownElem<'w, 'l, 'h, 'r, 'sp, 'c, 'p, 't> () =
  +  inherit ProductDownBase<'w, 'c, 'p, 't> ()
  +
  +type ProductDown<'w, 'e, 'sp, 'c, 'p, 't> =
  +  | P of list<ProductDownBase<'w, 'c, 'p, 't>>
   
   type UnionDown<'w, 'c, 'cs, 'u> = U of list<Down<'w, 'u>>
   
   type [<AbstractClass>] Rotate<'l, 'h, 'r, 'sp, 'p> () =
     abstract Do: byref<'p> * byref<'l> * byref<'h> * byref<'r> -> unit
     abstract Un: byref<'l> * byref<'h> * byref<'r> * byref<'p> -> unit
  -
  -type Out = | Out'0
  -
  -type Prev<'h, 'sp, 'p, 'lh, 'lsp> = | Prev'5
  -type Head<'h, 'sp> = | Head'2
  -type Next<'h, 'sp, 'rh, 'rsp> = | Next'4
   
   type [<InferenceRules>] Zipper () =
     member z.ToZipper (_: Rep, _: Basic, down: Down<'w, 'w>) =
  
positive.code:          member d.DownLast (_, _) = None}]
  
    member z.Case (m: Case<'ls, 'cs, 'u>,
                   downFirst: ProductDown<'w, Empty, _, _, 'ls, 'cs, 'ls, 'u>,
                   downLast: ProductDown<'w, _, 'lh, Empty, 'lh, 'cs, 'ls, 'u>)
                    : UnionDown<'w, 'ls, 'cs, 'u> =
      U [z.Product (m, downFirst, downLast)]
  
    member z.Plus (U c:  UnionDown<'w,        'c      , Choice<'c, 'cs>, 'u>,
                   U cs: UnionDown<'w,            'cs ,            'cs , 'u>)
  
negative.code:         cs.[m.Tag u].DownFirst (up, u)
        override d.DownLast (up, u) =
          cs.[m.Tag u].DownLast (up, u)}
  
    member r.Nest (r0: Rotate<'l, 'h, 'r, 'sp, 'p>) =
      {new Rotate<And<'l0, 'l>, 'h, 'r, 'sp, And<'l0, 'p>> () with
  