anchor.diff:                  let fieldMolds =
                       FSharpType.GetRecordFields ty |>
                       Array.map (fun propertyInfo -> (propertyInfo.Name, propertyInfo.PropertyType)) |>
  -                    Array.map (fun (name', ty') -> (name', typeToMold (Some (name, name')) ty' molder)) |>
  +                    Array.map (fun (name', ty') -> (name', typeToMold3 (Some (name, name')) ty' molder)) |>
                       Array.toList
                   moldRef := Record (pathOpt, name, fieldMolds)
               elif FSharpType.IsUnion ty then
  
positive.code:                 let caseMolds =
                      cases |>
                      Array.map (fun case ->
                          let fieldMolds = case.GetFields () |> Array.map (fun field -> typeToMold (Some (name, field.Name)) field.PropertyType molder) |> Array.toList
                          (case.Name, fieldMolds)) |>
                      Array.toList
                  moldRef := Union (pathOpt, name, caseMolds)
              elif ty.IsGenericType && ty.GetGenericTypeDefinition () = typedefof<_ option> then
                  let containedType = ty.GenericTypeArguments.[0]
                  let containedMold = typeToMold None containedType molder
                  moldRef := Option (pathOpt, containedMold)
              elif ty.IsGenericType && ty.GetGenericTypeDefinition () = typedefof<_ list> then
                  let elementType = ty.GenericTypeArguments.[0]
                  let elementMold = typeToMold None elementType molder
                  moldRef := List (pathOpt, elementMold)
              elif ty.IsGenericType && ty.GetGenericTypeDefinition () = typedefof<_ Set> then
                  let elementType = ty.GenericTypeArguments.[0]
                  let elementMold = typeToMold None elementType molder
                  moldRef := List (pathOpt, elementMold)
              elif ty.IsGenericType && ty.GetGenericTypeDefinition () = typedefof<Map<_, _>> then
                  let keyType = ty.GenericTypeArguments.[0]
                  let keyMold = typeToMold None keyType molder
                  let valueType = ty.GenericTypeArguments.[1]
                  let valueMold = typeToMold None valueType molder
                  moldRef := Map (pathOpt, keyMold, valueMold)
              elif ty.IsArray then
                  let elementType = ty.GetElementType ()
                  let elementMold = typeToMold None elementType molder
                  moldRef := List (pathOpt, elementMold)
              else
                  if molder.ForceIdentification
  
negative.code:         | IPAddress -> if molder.DefaultAsRandom then new IPAddress (int64 (molder.Random.Next ())) :> obj else Guid.Empty :> obj
          | Guid -> if molder.DefaultAsRandom then Guid.NewGuid () :> obj else Guid.Empty :> obj
  
      let rec private typeToMold3 pathOpt (ty : Type) molder =
          let key = (pathOpt, ty)
          match molder.Cache.TryGetValue key with
          | (false, _) ->
  