anchor.diff:                    U u: UnionDown<'w, 'c, 'c, 'u>) : Down<'w, 'u> =
       let cs = Array.ofList u
       {new Down<'w, 'u> () with
  -      override d.DownFirst (up, u) =
  -        cs.[m.Tag u].DownFirst (up, u)
  -      override d.DownLast (up, u) =
  -        cs.[m.Tag u].DownLast (up, u)}
  +      override d.DownHeadAny (up, u) = cs.[m.Tag u].DownHeadAny (up, u)
  +      override d.DownHeadThe (up, u) = cs.[m.Tag u].DownHeadThe (up, u)
  +      override d.DownLastAny (up, u) = cs.[m.Tag u].DownLastAny (up, u)
  +      override d.DownLastThe (up, u) = cs.[m.Tag u].DownLastThe (up, u)}
   
     member r.Nest (r0: Rotate<'l, 'h, 'r, 'sp, 'p>) =
       {new Rotate<And<'l0, 'l>, 'h, 'r, 'sp, And<'l0, 'p>> () with
  
positive.code:     let downs = Array.ofList downs
      let n = downs.Length
      for i=0 to n-1 do
        if 0 <= i-1 then downs.[i].L <- downs.[i-1]
        if i+1 < n then downs.[i].R <- downs.[i+1]
      let downFirst = downs.[0]
      let downLast = downs.[n-1]
      {new Down<'w, 't> () with
        member d.DownFirst (up, t) =
          let mutable p = m.ToProduct t
          downFirst.Down (up, m, &p) |> Some
        member d.DownLast (up, t) =
          let mutable p = m.ToProduct t
          downLast.Down (up, m, &p) |> Some}
  
    member z.Case (_: Case<Empty, 'cs, 'u>) : UnionDown<'w, Empty, 'cs, 'u> =
      U [{new Down<'w, 'u> () with
           member d.DownFirst (_, _) = None
           member d.DownLast (_, _) = None}]
  
    member z.Case (m: Case<'ls, 'cs, 'u>,
                   downs: ProductDown<'w, 'ls, 'ls, 'cs, 'ls, 'u>)
  
negative.code: 
  ////////////////////////////////////////////////////////////////////////////////
  
  let toZipperAny (x: 'x) : Zipper<'x> =
    (StaticRules<Zipper>.Generate() : Up<'x, 'x>).Up x
  let toZipperThe (x: 'x) : Zipper<'x, 'x> =
    match toZipperAny x with
     | :? Zipper<'x, 'x> as z -> z
     | _ -> failwith "Bug"
  
  let inline getThe (xZ: Zipper<'x, 'x>) : 'x = xZ.Get ()
  let getAny (xZ: Zipper<'x>) : option<'y> =
    match xZ with
     | :? Zipper<'x, 'y> as xyZ -> xyZ.Get () |> Some
     | _ -> None
  
  let setAny (y: 'y) (xZ: Zipper<'x>) =
    match xZ with
     | :? Zipper<'x, 'y> as xyZ -> xyZ.Set y |> Some
     | _ -> None
  let inline setThe (x: 'x) (xZ: Zipper<'x, 'x>) = xZ.Set x
  
  let inline upAny (xZ: Zipper<'x>) = xZ.Up ()
  let inline downHeadAny (xZ: Zipper<'x>) = xZ.DownHeadAny ()
  let inline downHeadThe (xZ: Zipper<'x>) = xZ.DownHeadThe ()
  let inline downLastAny (xZ: Zipper<'x>) = xZ.DownLastAny ()
  let inline downLastThe (xZ: Zipper<'x>) = xZ.DownLastThe ()
  let inline nextAny (xZ: Zipper<'x>) = xZ.NextAny ()
  let inline nextThe (xZ: Zipper<'x>) = xZ.NextThe ()
  let inline prevAny (xZ: Zipper<'x>) = xZ.PrevAny ()
  let inline prevThe (xZ: Zipper<'x>) = xZ.PrevThe ()
  
  let rec upThe (xZ: Zipper<'x>) : option<Zipper<'x, 'x>> =
    match upAny xZ with
     | None -> None
     | Some xZ ->
       match xZ with
        | :? Zipper<'x, 'x> as xZ -> Some xZ
        | _ -> upThe xZ
  
  let rec fromZipper (xZ: Zipper<'x>) : 'x =
    match upAny xZ with
     | None ->
       match xZ with
        | :? Zipper<'x, 'x> as xxZ -> xxZ.Get ()
  