anchor.diff:  
       checkForFile startFolder
   
  -let membersToIgnore =
  -    [
  -        "ToString"
  -        "Equals"
  -        "GetHashCode"
  -        "GetType"
  -        "Invoke"
  -    ] |> List.toSeq |> Set
  -
   let findProhibitedTypes (prohibitedTypes : TypeInfo seq) (subjectType : TypeInfo) 
           : (TypeInfo * MemberInfo * Type seq) seq =
   
  -    let filterMembers (m : MemberInfo) = not (membersToIgnore |> Set.contains m.Name)
  +    let filterMember (m : MemberInfo) = not (Exclusions.exludeMember m)
   
       let prohibitedTypes' = prohibitedTypes |> Seq.map (fun ti -> ti.AsType()) |> Seq.cache
       let check = Details.Check(prohibitedTypes')
  
positive.code:             | :? FileLoadException as ex ->
                  eprintfn "Couldn't load file '%s'" ex.FileName
                  reraise()
          |> Seq.filter (fun ti -> ti.Name <> "<>c")
          |> Seq.cache
  
      //printfn "Public types for %s" (Path.GetFileName(assemblyPath))
  
negative.code:         let ts' = ts |> Seq.cache
          ts' |> Seq.iter (fun t -> printfn "  %s: %A" name t)
          ts'
  
  module Exclusions =
  
      type private ClassExclusion = DebugTypeProxy | FullName of string
  
      let private classExclusions = [
          DebugTypeProxy
          FullName "<>c"
      ]
  
      let excludeClass (ti : TypeInfo) =
          let name = ti.Name
  
          classExclusions |>
          Seq.exists (fun ex ->   match ex with
                                  | DebugTypeProxy -> name.EndsWith("@DebugTypeProxy")
                                  | FullName n -> name = n)
  
      let private membersToIgnore =
          [
              "ToString"
              "Equals"
              "GetHashCode"
              "GetType"
              "Invoke"
          ] |> List.toSeq |> Set
  
      let exludeMember (m : MemberInfo) = membersToIgnore |> Set.contains m.Name
  
  module Details =
      open System.Text.RegularExpressions
  