anchor.diff:        logger.Success ("Found the following traces for " + (PackageIdentifier.show package) + ": ")
   
         for trace in traces do
  -        logger.Print <| " @ -> " + (trace |> List.rev |> Seq.map (PackageIdentifier.show) |> String.concat " -> ")
  +        logger.Print
  +          <| " @ " +
  +            (
  +              trace
  +              |> List.rev
  +              |> Seq.map (fun (package, isPrivate) ->
  +                let arrow =
  +                  if isPrivate
  +                  then
  +                    "--{private}--> "
  +                  else
  +                    "-----> "
  +                arrow + PackageIdentifier.show package
  +              )
  +              |> String.concat " "
  +            )
   
       return 0
     | None ->
  
positive.code:     computeTraces directDependencies
      |> AsyncSeq.filter (fun trace ->
        match trace with
        | head :: _ -> head = packageToExplain
        | _ -> false
      )
      |> AsyncSeq.distinctUntilChanged
  
negative.code:     for trace in traces do
        match trace with
        | head :: tail ->
          let package, isPrivate = head
  
          match lock.Packages |> Map.tryFind package with
          | Some lockedPackage ->
            yield head :: tail
  
            logger.Info ("Exploring " + (PackageIdentifier.show package) + "... ")
  
            let! manifest =
              sourceExplorer.FetchManifest (lockedPackage.Location, lockedPackage.Versions)
  
            let nextTraces =
              manifest.Dependencies
              |> Seq.map (fun dependency -> (dependency, false))
              |> Seq.append (manifest.PrivateDependencies |> Seq.map (fun dependency -> (dependency, true)))
              |> Seq.map (fun (dependency, isPrivate) -> (dependency.Package, isPrivate) :: head :: tail)
              |> Set.ofSeq
  
            yield! nextTraces |> AsyncSeq.ofSeq
  