anchor.diff:          | EmbeddedResource -> "EmbeddedResource"
   
       static member Parse text = text |> function
  -        | "Compile"          -> Compile          
  -        | "Content"          -> Content          
  -        | "Reference"        -> Reference        
  -        | "None"             -> None             
  -        | "Resource"         -> Resource         
  -        | "EmbeddedResource" -> EmbeddedResource 
  +        | "Compile"          -> Compile
  +        | "Content"          -> Content
  +        | "Reference"        -> Reference
  +        | "None"             -> None
  +        | "Resource"         -> Resource
  +        | "EmbeddedResource" -> EmbeddedResource
           | _                  -> failwithf "Could not parse '%s' into a `BuildAction`" text
   
       static member TryParse text = text |> function
  -        | "Compile"          -> Some Compile          
  -        | "Content"          -> Some Content          
  -        | "Reference"        -> Some Reference        
  -        | "None"             -> Some None             
  -        | "Resource"         -> Some Resource         
  -        | "EmbeddedResource" -> Some EmbeddedResource 
  +        | "Compile"          -> Some Compile
  +        | "Content"          -> Some Content
  +        | "Reference"        -> Some Reference
  +        | "None"             -> Some None
  +        | "Resource"         -> Some Resource
  +        | "EmbeddedResource" -> Some EmbeddedResource
           | _                  -> Option.None
   
   
   // Under "Compile" in https://msdn.microsoft.com/en-us/library/bb629388.aspx
   type CopyToOutputDirectory =
       | Never | Always | PreserveNewest
  -       
  +
       override self.ToString () = self |> function
           | Never          -> "Never"
           | Always         -> "Always"
  
positive.code:     | Pair      of SourcePair
      | Directory of SourceElement list
  
      member self.ToXElem () : XElement list = 
          match self with
          | File  x       -> [x.ToXElem()]
          | Pair  x       -> x.ToXElem() 
          | Directory x   -> x |> List.collect (fun e -> e.ToXElem())
  
  
  
negative.code:         if not (proj.References |> List.exists ((=) refr)) then proj else
          { proj with References = proj.References |> List.filter ((<>) refr) }
  
      let addFile (file : SourceElement) (proj:FsProject) =
          if proj.SourceFiles |> List.exists ((=) file) then proj else
          { proj with SourceFiles = file::proj.SourceFiles }
  
      let removeFile (file : SourceElement) (proj:FsProject) =
          if not (proj.SourceFiles |> List.exists ((=) file)) then proj else
          { proj with SourceFiles = proj.SourceFiles |> List.filter ((<>) file) }
  
      let orderFile (fileToMove : SourceElement) (putBefore : SourceElement) (proj : FsProject) =
           if not (proj.SourceFiles |> List.exists ((=) fileToMove) ||proj.SourceFiles |> List.exists ((=) putBefore)) then proj else
           let filesBefore = proj.SourceFiles |> List.filter ((<>) fileToMove) |> List.takeWhile ((<>) putBefore)
           let filesAfter = proj.SourceFiles |> List.filter ((<>) fileToMove) |> List.skipWhile ((<>) putBefore)
           let filesNew = seq {yield! filesBefore; yield fileToMove; yield! filesAfter } |> Seq.toList
           { proj with SourceFiles = filesNew }
  
      let parse content =
          let xdoc = (XDocument.Parse content).Root
          let itemGroups = XElem.descendantsNamed "ItemGroup" xdoc
  
          let projectSettingsSqs =
              XElem.descendantsNamed "PropertyGroup" xdoc
              |> Seq.filter (fun pg -> not ^ XElem.hasAttribute "Condition" pg)
  
          let projectSettings = projectSettingsSqs |> Seq.head |> ProjectSettings.fromXElem
  
      //    let buildConfigs =
      //        XElem.descendantsNamed "PropertyGroup" xdoc
      //        |> Seq.filter (fun pg -> XElem.hasAttribute "Condition" pg)
  
          let projectReferences =
              XElem.descendantsNamed "ProjectReference" xdoc
              |> Seq.map ProjectReference.fromXElem
  
          let filterItems name =
              itemGroups |> Seq.collect ^ XElem.descendantsNamed name
  
          let references =
              filterItems "Reference"
              |> Seq.filter  (not << XElem.hasElement "Paket") // we only manage references paket isn't already managing
              |> Seq.map Reference.fromXElem
  
          let srcFiles =
              itemGroups
              |> Seq.collect (fun itemgroup ->
                  XElem.descendants itemgroup
                  |> Seq.filter (fun x -> isSrcFile x.Name.LocalName))
              |> Seq.map SourceFile.fromXElem
  
          let proj =
              {   ToolsVersion      =  XElem.getAttribute "ToolsVersion" xdoc |> XAttr.value
                  DefaultTargets    =  [XElem.getAttribute "DefaultTargets" xdoc |> XAttr.value]
                  References        = references |> List.ofSeq
                  Settings          = projectSettings
                  SourceFiles       = srcFiles |> Seq.map File |> List.ofSeq
                  ProjectReferences = projectReferences |> List.ofSeq
                  BuildConfigs      = []
              }
  
          proj
  
      let load path =
          let content = System.IO.File.ReadAllText path
          parse content
  
  // A small abstraction over MSBuild project files.
  type ProjectFile (projectFileName:string, documentContent:string) =
  