anchor.diff:              | :? InterfaceDef as idef ->
                   add idef.Name def overwrite
                   idef.Fields
  -                |> Seq.map (fun x -> match named x.TypeDef with Some n -> n | _ -> failwith "Expected a Named type!")
  +                |> Seq.map (fun x -> asNamed x.TypeDef)
                   |> Seq.filter (fun x -> not (map.ContainsKey(x.Name)))
                   |> Seq.iter insert
               | :? UnionDef as udef ->
  
positive.code:                 |> Map.toSeq
                  |> Seq.map snd
                  |> Seq.collect (fun x -> Seq.append (x.TypeDef :> TypeDef |> Seq.singleton) (x.Args |> Seq.map (fun a -> upcast a.TypeDef)))
                  |> Seq.map (fun x -> match named x with Some n -> n | _ -> failwith "Expected a Named type!")
                  |> Seq.filter (fun x -> not (map.ContainsKey(x.Name)))
                  |> Seq.iter insert
                  odef.Implements
  
negative.code:             then map.Add(name, def)
              elif overwrite
              then map.[name] <- def
          let asNamed x = 
              match named x with 
              | Some n -> n
              | _ -> failwith "Expected a Named type!"
          let rec insert (def : NamedDef) =
              match def with
              | :? ScalarDef as sdef -> add sdef.Name def overwrite
  