anchor.diff:                                                       |> dict
           applicationMap
   
  -    member this.ProjectMap : System.Collections.Generic.IDictionary<Anthology.ProjectId, Project> = 
  +    member this.ProjectMap : System.Collections.Generic.IDictionary<Anthology.ProjectId, Project> =
           if projectMap |> isNull then
               projectMap <- anthology.Projects |> Seq.map (fun x -> x.ProjectId, { Graph = this; Project = x } )
                                                |> dict
  
positive.code:     member this.Uri = this.Repository.Url.toString
  
      member this.Projects =
          let repositoryId = this.Repository.Name
          this.Graph.Anthology.Projects |> Set.filter (fun x -> x.Repository = repositoryId)
                                        |> Set.map (fun x -> this.Graph.ProjectMap.[x.ProjectId])
  
      member this.IsCloned =
          let wsDir = Env.GetFolder Env.Folder.Workspace
          let repoDir = wsDir |> IoHelpers.GetSubDirectory this.Name
          repoDir.Exists
  
      member this.References = 
          this.Projects |> Set.map (fun x -> x.References |> Set.map (fun y -> y.Repository))
                        |> Set.unionMany
                        |> Set.remove this
  
      member this.ReferencedBy = 
          this.Projects |> Set.map (fun x -> x.ReferencedBy |> Set.map (fun y -> y.Repository))
                        |> Set.unionMany
                        |> Set.remove this
  
      static member Closure (seeds : Repository set) =
          Algorithm.Closure seeds (fun x -> x.References) (fun x -> x.ReferencedBy)
  
negative.code:         assemblyMap
  
      member this.RepositoryMap : System.Collections.Generic.IDictionary<Anthology.RepositoryId, Repository> =
          if repositoryMap |> isNull then
              repositoryMap <- anthology.Repositories |> Seq.map (fun x -> x.Repository.Name, { Graph = this; Repository = x.Repository})
                                                      |> dict
          repositoryMap
  
  