anchor.diff:      let rec moldToType mold molder =
           match mold with
           | Primitive (_, primitive) -> moldToPrimitive primitive molder
  -        | Tuple (_, _, molds) -> let types = molds |> List.map (fun mold' -> moldToType mold' molder) |> List.toArray in FSharpType.MakeTupleType types
  +        | Tuple (_, _, molds) -> let types = molds |> Array.map (fun mold' -> moldToType mold' molder) in FSharpType.MakeTupleType types
           | Record (_, name, _) -> Type.GetType name
           | Union (_, name, _) -> Type.GetType name
           | Option (_, mold) -> let containedType = moldToType mold molder in typedefof<_ option>.MakeGenericType containedType
  
positive.code:         | Single
          | Double
          | Decimal
          | Enum of string * string list
          | DateTime
          | IPAddress
          | Guid
  
      /// Describes an F# type in a normalized fashion.
      type Mold =
          | Primitive of Path option * Primitive
          | Tuple of Path option * string * Mold list
          | Record of Path option * string * (string * Mold) list
          | Union of Path option * string * (string * Mold list) list
          | Option of Path option * Mold
          | List of Path option * Mold
          | Set of Path option * Mold
          | Map of Path option * Mold * Mold
          | Array of Path option * Mold
          | Unidentified of Path option
  
          static member getPathOpt mold =
              match mold with
              | Primitive (pathOpt, _)
              | Tuple (pathOpt, _, _)
  
negative.code:                 primitiveToInstance primitive molder
              | Tuple (_, name, elementMolds) ->
                  let ty = Type.GetType name
                  let elements = Array.map (fun ty' -> moldToInstance ty' molder) elementMolds
                  FSharpValue.MakeTuple (elements, ty)
              | Record (_, name, fieldMolds) ->
                  let ty = Type.GetType name
                  let fields = Array.map (snd >> fun ty' -> moldToInstance ty' molder) fieldMolds
                  FSharpValue.MakeRecord (ty, fields)
              | Union (_, name, caseMolds) ->
                  let ty = Type.GetType name
                  let caseInfos = FSharpType.GetUnionCases ty
                  let caseInfo = caseInfos.[0]
                  let (_, caseFields) = caseMolds.[0]
                  let caseFieldInstances = Array.map (fun ty' -> moldToInstance ty' molder) caseFields
                  FSharpValue.MakeUnion (caseInfo, caseFieldInstances)
              | Option (_, _) ->
                  None :> obj
  