anchor.diff:    // Recursion rule ------------------------------------------------------------
   
     // Rule for creating a proxy when defining a recursive cloning function.
  -  member this.Fix (recFn: RecFn) : Rec<CloneSmart<'t>> =
  -    let proxy : ref<CloneSmart<'t>> = ref null
  +  member this.Fix (recFn: RecFn) : Rec<CloneSmarter<'t>> =
  +    let proxy : ref<CloneSmarter<'t>> = ref null
       let clone =
  -      {new CloneSmart<'t> () with
  +      {new CloneSmarter<'t> () with
           override this.Clone (x) =
            match !proxy with
             | null -> x
             | clone -> clone.Clone (x)}
  -    {new Rec<CloneSmart<'t>> () with
  +    {new Rec<CloneSmarter<'t>> () with
         override this.Get () = clone
         override this.Set (clone) = proxy := clone}
   
     // Rules for simple base types -----------------------------------------------
   
     /// A rule for the `int32` type.
  -  member this.Int : CloneSmart<int> = null  // Nothing to copy!
  +  member this.Int : CloneSmarter<int> = null  // Nothing to copy!
   
     /// A rule for the `string` type.
  -  member this.String : CloneSmart<string> = null // Nothing to copy!
  +  member this.String : CloneSmarter<string> = null // Nothing to copy!
   
     // Rules for some specific type constructors ---------------------------------
   
     /// A rule for the `ref<'t>` type constructor.
  -  member this.Ref (cloneT: CloneSmart<'t>) : CloneSmart<ref<'t>> =
  -    match cloneT with
  +  member this.Ref (cloneX': CloneSmarter<'t>) : CloneSmarter<ref<'t>> =
  +    match cloneX' with
        | null ->
  -       {new CloneSmart<ref<'t>> () with
  +       {new CloneSmarter<ref<'t>> () with
            override this.Clone (original) =
             ref (!original)}
  -     | cloneT ->
  -       {new CloneSmart<ref<'t>> () with
  -         override this.Clone (original) =
  -          ref (!original)}
  +     | cloneX ->
  +       {new CloneSmarter<ref<'t>> () with
  +         override this.Clone (original) =
  +          ref (cloneX.Clone (!original))}
   
     /// A rule for the `array<'t>` type constructor.
  -  member this.Array (cloneX: CloneSmart<'x>) : CloneSmart<array<'x>> =
  -    match cloneX with
  +  member this.Array (cloneX': CloneSmarter<'x>) : CloneSmarter<array<'x>> =
  +    match cloneX' with
        | null ->
  -       {new CloneSmart<array<'x>> () with
  +       {new CloneSmarter<array<'x>> () with
            override this.Clone (original) =
             Array.copy original}
        | cloneX ->
  -       {new CloneSmart<array<'x>> () with
  +       {new CloneSmarter<array<'x>> () with
            override this.Clone (original) =
             Array.map (fun x -> cloneX.Clone (x)) original}
   
  
positive.code:       null
      else
        let identity =
          {new CloneSmart<'t> () with 
            override this.Clone (original) = original}
        let cloneUnion =
          Array.ofList cloneUnion
  
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`.
  