anchor.diff:                  let name = (ty.GetGenericTypeDefinition ()).AssemblyQualifiedName
                   let elementMolds =
                       FSharpType.GetTupleElements ty |>
  -                    Array.map (fun ty' -> typeToMold3 None ty' molder) |>
  -                    Array.toList
  +                    Array.map (fun ty' -> typeToMold3 None ty' molder)
                   moldRef := Tuple (pathOpt, name, elementMolds)
               elif FSharpType.IsRecord ty then
                   let name = ty.AssemblyQualifiedName
                   let fieldMolds =
                       FSharpType.GetRecordFields ty |>
                       Array.map (fun propertyInfo -> (propertyInfo.Name, propertyInfo.PropertyType)) |>
  -                    Array.map (fun (name', ty') -> (name', typeToMold3 (Some (name, name')) ty' molder)) |>
  -                    Array.toList
  +                    Array.map (fun (name', ty') -> (name', typeToMold3 (Some { TypeName = name; MemberName = name' }) ty' molder))
                   moldRef := Record (pathOpt, name, fieldMolds)
               elif FSharpType.IsUnion ty then
                   let name = ty.AssemblyQualifiedName
                   let cases = FSharpType.GetUnionCases ty
                   let caseMolds =
  -                    cases |>
  -                    Array.map (fun case ->
  -                        let fieldMolds = case.GetFields () |> Array.map (fun field -> typeToMold3 (Some (name, field.Name)) field.PropertyType molder) |> Array.toList
  -                        (case.Name, fieldMolds)) |>
  -                    Array.toList
  +                    Array.map (fun (case : UnionCaseInfo) ->
  +                        let fieldMolds =
  +                            case.GetFields () |>
  +                            Array.map (fun field -> typeToMold3 (Some { TypeName = name; MemberName = field.Name }) field.PropertyType molder)
  +                        (case.Name, fieldMolds))
  +                        cases
                   moldRef := Union (pathOpt, name, caseMolds)
               elif ty.IsGenericType && ty.GetGenericTypeDefinition () = typedefof<_ option> then
                   let containedType = ty.GenericTypeArguments.[0]
  
positive.code:             elif ty = typeof<System.Single> then moldRef := Primitive (pathOpt, Single)
              elif ty = typeof<System.Double> then moldRef := Primitive (pathOpt, Double)
              elif ty = typeof<System.Decimal> then moldRef := Primitive (pathOpt, Decimal)
              elif ty.IsEnum then moldRef := Primitive (pathOpt, Enum (ty.AssemblyQualifiedName, Array.toList (Enum.GetNames ty)))
              elif ty = typeof<System.DateTime> then moldRef := Primitive (pathOpt, DateTime)
              elif ty = typeof<System.Net.IPAddress> then moldRef := Primitive (pathOpt, IPAddress)
              elif ty = typeof<System.Guid> then moldRef := Primitive (pathOpt, Guid)
  
negative.code: open System.Collections.Generic
  open FSharp.Reflection
  
  type MemberPath =
      { TypeName : string
        MemberName : string }
  
  type [<NoEquality; NoComparison>] InstantiationRule =
      | Constant of obj
      | Variable of (unit -> obj)
  
  type InstantiationRules =
      Map<MemberPath option, InstantiationRule>
  
  [<RequireQualifiedAccess>]
  module Molder =
  
      // A primitive mold type.
      type Primitive =
          | Unit
          | Boolean
  