anchor.diff:                  (Builder.emit
                     (OpCodes.Call,
                      FSharpValue.PreComputeUnionConstructorInfo
  -                    (cases.[i], B.Public ||| B.NonPublic)))
  +                    (cases.[i], B.Public)))
                   caseFields.[i]
                   caseProducts.[i] >>= fun () ->
  -               Builder.forTo 0 (caseFields.[i].Length-1) (fun j ->
  +               Builder.forTo 0 (caseFields.[i].Length-1) <| fun j ->
                   Builder.metaField
                    (typedefof<Label<_,_,_,_>>.MakeGenericType
                      [|caseFields.[i].[j].PropertyType;
  
positive.code:     let typeBuilder = repModule.DefineType (uniqueName (), T.Public, baseType)
      let (values, ()) = builder (typeBuilder, [])
      let baseArgTypes =
        match baseType.GetConstructors
               (B.Instance ||| B.Public ||| B.NonPublic) with
         | [|baseCtor|] when baseCtor.GetParameters().Length = basePars.Length ->
           let baseArgTypes =
             baseCtor.GetParameters () |> Array.map (fun p -> p.ParameterType)
  
negative.code:          Builder.emit (OpCodes.Ldarg_1) >>
           Builder.emit (OpCodes.Call, getMethod)
      let rec emitLoadAddr arg i =
        if i = 0
        then Builder.emit arg
        else emitLoadAddr arg (i-1)
             >> if i <> products.Length-1
                then Builder.emit (OpCodes.Ldflda, getField products.[i-1] "Rest")
                else id
      let emitLoadOrStore objOp fldOp i =
        if products.Length = 1
        then Builder.emit (objOp, products.[i])
        else Builder.emit (fldOp, if i < products.Length-1
                                  then getField products.[i] "Elem"
                                  else getField products.[i-1] "Rest")
      let emitStore = emitLoadOrStore OpCodes.Stobj OpCodes.Stfld
      let emitCopy i =
        emitLoadAddr OpCodes.Ldarg_2 i >> emitGet i >> emitStore i
      let rec emitCopies n =
        if n > 1 then emitCopies (n-1) else id
        >> emitCopy (n-1)
      let emitLoad i =
        emitLoadAddr OpCodes.Ldarg_1 i >>
        emitLoadOrStore OpCodes.Ldobj OpCodes.Ldfld i
      let rec emitLoads n =
        if n > 1 then emitLoads (n-1) else id
        >> emitLoad (n-1)
      Builder.overrideMethod "Extract"
       typeof<Void>
       [|t; products.[0].MakeByRefType ()|]
       (if props.Length > 0 then emitCopies props.Length else id
        >> Builder.emit (OpCodes.Ret)) >>= fun () ->
      Builder.overrideMethod "Create"
       t
       [|products.[0].MakeByRefType ()|]
       (if props.Length > 0 then emitLoads props.Length else id
        >> emitCtor
        >> Builder.emit (OpCodes.Ret))
  
    let asPairsField (t: Type)
                     (emitCtor: ILGenerator -> ILGenerator)
  