anchor.diff:                  | None -> 
                       // all added
                       dependenciesFileGroup.RemoteFiles 
  -                    |> List.map createUnresolvedVersion 
  +                    |> List.map RemoteFileChange.CreateUnresolvedVersion 
                       |> Set.ofList 
               | None -> 
                   // all removed
                   lockFile.GetGroup(groupName).RemoteFiles
  -                |> List.map createResolvedVersion
  +                |> List.map RemoteFileChange.CreateResolvedVersion
                   |> Set.ofList
               |> Set.map (fun x -> groupName,x))
       |> Seq.concat
  
positive.code:           | :? RemoteFileChange as that -> RemoteFileChange.Compare(this,that)
            | _ -> invalidArg "that" "cannot compare value of different types"
  
  
  let findRemoteFileChangesInDependenciesFile(dependenciesFile:DependenciesFile,lockFile:LockFile) =
      let groupNames =
          dependenciesFile.Groups
          |> Seq.map (fun kv -> kv.Key)
          |> Seq.append (lockFile.Groups |> Seq.map (fun kv -> kv.Key))
  
      let createUnresolvedVersion (unresolved:ModuleResolver.UnresolvedSourceFile) : RemoteFileChange =
            { Owner = unresolved.Owner
              Project = unresolved.Project
              Name = unresolved.Name
              Origin = unresolved.Origin
              Commit = unresolved.Commit
              AuthKey = unresolved.AuthKey }
  
      let createResolvedVersion (resolved:ModuleResolver.ResolvedSourceFile) : RemoteFileChange =
            { Owner = resolved.Owner
              Project = resolved.Project
              Name = resolved.Name
              Origin = resolved.Origin
              Commit = Some resolved.Commit
              AuthKey = resolved.AuthKey }
  
      groupNames
      |> Seq.map (fun groupName ->
  
negative.code:                 | Some lockFilegroup ->
                      let lockFileRemoteFiles =
                          lockFilegroup.RemoteFiles
                          |> List.map RemoteFileChange.CreateResolvedVersion
                          |> Set.ofList
  
                      let dependenciesFileRemoteFiles =
                          dependenciesFileGroup.RemoteFiles
                          |> List.map RemoteFileChange.CreateUnresolvedVersion
                          |> Set.ofList
  
                      let u =
  