anchor.diff:        mk
   
     member z.Pos (_: Elem<'r, 'r, 'p>,
  -                down: Z<'w, 'r>,
  -                PI left: PIZ<        'ls , And<'l, 'r>, 'w, 'p>)
  -                       : PIZ<And<'l, 'ls>,         'r , 'w, 'p> =
  +                down: Down<'w, 'r>,
  +                PI left: ProductDownI<        'ls , And<'l, 'r>, 'w, 'p>)
  +                       : ProductDownI<And<'l, 'ls>,         'r , 'w, 'p> =
       PI <| fun wllsrC ->
         let wlslrC (And (ls, And (l, r))) = And (And (l, ls), r) |> wllsrC
         let rec mk (And (And (l, ls), r)) =
  
positive.code:       mk
  
    member z.Pos (_: Elem<'r, And<'r, 'rs>, 'p>,
                  down: Z<'w, 'r>,
                  P0 left : P0Z<             And<'l, And<'r, 'rs>>, 'w, 'p>,
                  PI right: PIZ<And<'r, 'l>,                 'rs  , 'w, 'p>)
                          : PIZ<        '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))) =
  
negative.code:       mk
  
    member z.Product (m: AsProduct<'es, '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 _ _ -> None]
  
    member z.Case (m: Case<'ls, 'cs, 'u>,
                   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>)
  