anchor.diff:  /// (if we succeed we override the inferred schema, otherwise, we just
   /// override the header name)
   let private parseSchemaItem str forSchemaOverride =     
  -  let name, typ, unit, isOverride = 
  +  let name, typ, unit, isOverrideByName, originalName = 
       let m = overrideByNameRegex.Match str
       if m.Success && forSchemaOverride then
         // name=type|type<measure>
  -      let name = m.Groups.["name"].Value.TrimEnd()
  +      let originalName = m.Groups.["name"].Value.TrimEnd()
  +      let newName = m.Groups.["newName"].Value.Trim()
         let typeAndUnit = m.Groups.["type"].Value.Trim()
         let typ, unit = parseTypeAndUnit typeAndUnit
  -      if typ.IsNone then
  +      if typ.IsNone && typeAndUnit <> "" then
           failwithf "Invalid type: %s" typeAndUnit
  -      name, typ, unit, true
  +      newName, typ, unit, true, originalName
       else
         let m = nameAndTypeRegex.Match(str)
         if m.Success then
  
positive.code:     | None ->
          let parseResult = parseSchemaItem item false
          match parseResult with
          | SchemaParseResult.Name -> 
              makeUnique item, None
          | SchemaParseResult.NameAndUnit (name, unit) -> 
              // store the original header because the inferred type might not support units of measure
              (makeUnique item) + "\n" + (makeUnique name), Some unit
  
negative.code:         | item -> 
              let parseResult = parseSchemaItem item true
              match parseResult with
              | SchemaParseResult.Name name ->
                  headers.[index] <- name
              | SchemaParseResult.Full prop -> 
                  let name = 
                    if prop.Name = "" then headers.[index]
                    else prop.Name
                  schema.[index] <- Some { prop with Name = makeUnique name }
              | SchemaParseResult.Rename (name, originalName) ->
                  let index = headers |> Array.tryFindIndex (fun header -> header.Equals(originalName, StringComparison.OrdinalIgnoreCase))
                  match index with
                  | Some index -> 
                      headers.[index] <- name
                  | None -> failwithf "Column '%s' not found in '%s'" originalName (headers |> String.concat ",")
              | SchemaParseResult.FullByName (prop, originalName) -> 
                  let index = headers |> Array.tryFindIndex (fun header -> header.Equals(originalName, StringComparison.OrdinalIgnoreCase))
                  match index with
                  | Some index -> 
                      let name = 
                        if prop.Name = "" then headers.[index]
                        else prop.Name
                      schema.[index] <- Some { prop with Name = makeUnique name }
                  | None -> failwithf "Column '%s' not found in '%s'" originalName (headers |> String.concat ",")
              | _ -> failwithf "inferType: Unexpected SchemaParseResult for schema: %A" parseResult
        schema
  
  