anchor.diff:        mk
   
     member z.Product (m: AsProduct<'es, 'p>,
  -                    P0 down: P0Z<'es, 'w, 'p>) : Z<'w, 'p> =
  +                    P0 down: ProductDown0<'es, 'w, 'p>) : Down<'w, 'p> =
       fun wpC -> m.ToProduct >> down (m.OfProduct >> wpC) >> Some
   
     member z.Case (_: Case<Empty, 'cs, 'u>) : UZ<Empty, 'cs, 'w, 'u> =
  -    U [fun u wuC -> None]
  +    U [fun _ _ -> None]
   
     member z.Case (m: Case<'ls, 'cs, 'u>,
  -                 P0 down: P0Z<'ls, 'w, 'u>) : UZ<'ls, 'cs, 'w, 'u> =
  -    U [fun wuC -> m.ToProduct >> down (m.OfProduct >> wuC) >> Some]
  +                 down: ProductDown0<'ls, 'w, 'u>) : UZ<'ls, 'cs, 'w, 'u> =
  +    U [z.Product (m, down)]
   
     member z.Plus (U c:  UZ<       'c      , Choice<'c, 'cs>, 'w, 'u>,
                    U cs: UZ<           'cs ,            'cs , 'w, 'u>)
  
positive.code:   abstract Get: unit -> 'h
    abstract Set: 'h -> Zipper<'w>
  
  type Context<'w, 'h> = 'h -> Zipper<'w>
  
  type Z<'w, 'h> = Context<'w, 'h> -> 'h -> option<Zipper<'w>>
  
  type P0Z<'rs, 'w, 'p> =
    P0 of (Context<'w, 'rs> -> 'rs -> Zipper<'w>)
  type PIZ<'ls, 'rs, 'w, 'p> =
    PI of (Context<'w, And<'ls, 'rs>> -> And<'ls, 'rs> -> Zipper<'w>)
  
  type UZ<'c, 'cs, 'w, 'u> = U of list<Z<'w, 'u>>
  
  type [<InferenceRules>] Zipper () =
    member z.ToZipper (_: Rep,
                       _: Rec,
                       down: Z<'w, 'w>) : 'w -> Zipper<'w> =
      let rec mk w =
        {new Zipper<'w, 'w> with
          override z.Get () = w
          override z.Set w = mk w
          override z.Up () = None
          override z.Down () = z.Get () |> down z.Set
          override z.Left () = None
          override z.Right () = None} :> Zipper<_>
      mk
  
    member z.Prim (_: Prim<'t>) : Z<'w, 't> =
      fun tC ->
        let rec mk t =
          {new Zipper<'w, 't> with
            override z.Get () = t
            override z.Set t = mk t
            override z.Up () = None
            override z.Down () = None
            override z.Left () = None
            override z.Right () = None} :> Zipper<_>
        mk >> Some
  
    member z.Pos (_: Elem<'r, 'r, 'p>, down: Z<'w, 'r>) : P0Z<'r, 'w, 'p> =
      P0 <| fun wrC ->
        let rec mk r =
          {new Zipper<'w, 'r> with
            override z.Get () = r
            override z.Set r = r |> mk
            override z.Up () = r |> wrC |> Some
            override z.Down () = down z.Set r
            override z.Left () = None
            override x.Right () = None} :> Zipper<_>
        mk
  
    member z.Pos (_: Elem<'r, And<'r, 'rs>, 'p>,
                  down: Z<'w, 'r>,
                  PI right: PIZ<    'r, 'rs , 'w, 'p>)
                          : P0Z<And<'r, 'rs>, 'w, 'p> =
      P0 <| fun wrrsC ->
        let rec mk (And (r, rs)) =
          {new Zipper<'w, 'r> with
  
negative.code:       mk
  
    member z.Pos (_: Elem<'r, And<'r, 'rs>, 'p>,
                  down: Down<'w, 'r>,
                  P0 left : ProductDown0<             And<'l, And<'r, 'rs>>, 'w, 'p>,
                  PI right: ProductDownI<And<'r, 'l>,                 'rs  , 'w, 'p>)
                          : ProductDownI<        'l ,         And<'r, 'rs> , 'w, 'p> =
      PI <| fun wlrrsC ->
        let wrlrsC (And (And (r, l), rs)) = And (l, And (r, rs)) |> wlrrsC
        let rec mk (And (l, And (r, rs))) =
  