anchor.diff:       | (null, cloneProductRest) ->
          {new CloneProduct<And<'e, 'es>, And<'e, 'es>, 't> () with
            override this.Clone (ees: byref<And<'e, 'es>>) =
  -          cloneProductRest.Clone (&ees.Rest)}
  +          cloneProductRest.Clone (&ees.Rest)
  +         override this.ForAll (pred) =
  +          cloneProductRest.ForAll pred}
        | (cloneProductElem, null) ->
          {new CloneProduct<And<'e, 'es>, And<'e, 'es>, 't> () with
            override this.Clone (ees: byref<And<'e, 'es>>) =
  -          cloneProductElem.Clone (&ees.Elem)}
  +          cloneProductElem.Clone (&ees.Elem)
  +         override this.ForAll (pred) =
  +          cloneProductElem.ForAll pred}
        | (cloneProductElem, cloneProductRest) ->
          {new CloneProduct<And<'e, 'es>, And<'e, 'es>, 't> () with
            override this.Clone (ees: byref<And<'e, 'es>>) =
             cloneProductElem.Clone (&ees.Elem)
  -          cloneProductRest.Clone (&ees.Rest)}
  +          cloneProductRest.Clone (&ees.Rest)
  +         override this.ForAll (pred) =
  +          cloneProductElem.ForAll pred &&
  +          cloneProductRest.ForAll pred}
   
     /// A rule for cloning a specific element of type `'e` within a product.
  -  member this.Elem (_: Rep, _: Elem<'e, 'es, 't>, cloneElem: CloneSmart<'e>) =
  -    match cloneElem with
  +  member this.Elem (_: Rep, _: Elem<'e, 'es, 't>, cloneElem': CloneSmarter<'e>) =
  +    match cloneElem' with
        | null ->
          null
        | cloneElem ->
          {new CloneProduct<'e, 'es, 't> () with
            override this.Clone (e: byref<'e>) =
             // We just mutate the element in-place within the stack allocated space.
  -          e <- cloneElem.Clone (e)}
  +          e <- cloneElem.Clone (e)
  +         override this.ForAll (pred) =
  +          pred cloneElem}
  
positive.code: 
    /// A rule for cloning a non-nullary union case.
    member this.Case (case: Case<'ls, 'cs, 't>,
                      cloneProduct: CloneProduct<'ls, 'ls, 't>) : CloneUnion<'ls, 'cs, 't> =
      // We forward here to a helper function to avoid duplicating code.
      let cloneCase =
        CloneProductToCloneSmart (case :> AsProduct<'ls, 't>) cloneProduct
      // Then we return just this case. 
      CloneUnion [cloneCase]
  
  
negative.code:   member this.Product (_: Rep,
                         product: Product<'t>,
                         asProduct: AsProduct<'es, 't>,
                         cloneProduct': CloneProduct<'es, 'es, 't>) : CloneSmarter<'t> =
      // Do we need to copy something?
      match (product.IsMutable, cloneProduct') with
       | (false, null) ->
         null
       | (isMutable, cloneProduct) ->
         CloneProductToCloneSmart isMutable asProduct cloneProduct
  
    /// A rule for cloning a part of a product consisting of an `Elem: 'e` and
    /// `Rest: 'es`.
  