anchor.diff:                 directDeps : Set<PackageName>, 
                  lockFile : LockFile) :
                  Result<Reason, InferError> =
  -        let group = lockFile.GetGroup groupName
  -        if not <| group.Resolution.ContainsKey packageName then
  +
  +        let inferError () =
               let otherGroups =
                   lockFile.Groups 
                   |> Seq.filter (fun pair -> pair.Value.Resolution.ContainsKey packageName) 
                   |> Seq.map (fun pair -> pair.Key)
                   |> Seq.toList
               if List.isEmpty otherGroups then
  -                Result.Bad [NuGetNotInLockFile]
  +                NuGetNotInLockFile
               else
  -                Result.Bad [NuGetNotInGroup otherGroups]
  +                NuGetNotInGroup otherGroups
  +
  +        let group = lockFile.GetGroup groupName
  +        if not <| group.Resolution.ContainsKey packageName then
  +            inferError () 
  +            |> List.singleton 
  +            |> Result.Bad
           else
               let graph = depGraph group.Resolution
               let topLevelDeps = 
  
positive.code:             let chains = 
                  topLevelDeps
                  |> Set.toList
                  |> List.collect (fun p -> paths p packageName graph)
              match Set.contains packageName directDeps, Set.contains packageName topLevelDeps with
              | true, true ->
                  Result.Succeed TopLevel
  
negative.code: 
  type AdjGraph<'a> = list<'a * list<'a>>
  
  module AdjGraph =
      let adj n (g: AdjGraph<_>) =
          g
          |> List.find (fst >> (=) n)
          |> snd
  
      let rec paths start stop (g : AdjGraph<'a>) =
          if start = stop then [[start]]
          else
              [ for n in adj start g do
                  for path in paths n stop g do
                      yield start :: path ]
  
  let depGraph (res : PackageResolver.PackageResolution) : AdjGraph<Domain.PackageName> =
      res
  