anchor.diff:          |> AsyncSeq.mapAsync(fun candidate -> async {
             match candidate with
             | Result.Error e ->
  +            System.Console.WriteLine e
               return Result.Error e
             | Result.Ok (_, (location, versions)) ->
               let! lock = sourceExplorer.LockLocation location
  
positive.code:         |> AsyncSeq.distinctUntilChangedWith (fun prev next ->
            match prev, next with
            | (Result.Ok p), (Result.Ok n) ->
              p.Manifest = n.Manifest
            | (_, _) -> prev = next)
    }
  
    let zipState state clause =
      Result.map (fun candidate -> (clause, state, candidate))
      >> Result.mapError(fun e -> (clause, e))
  
    let mergeHint sourceExplorer next = async {
  
negative.code:           channel.Reply ()
    })
  
    let getHints (resolver: MailboxProcessor<ResolutionRequest>) state selections p cs = asyncSeq {
  
      let constraints =
        selections
        |> Map.valueList
        |> Seq.map fst
        |> Seq.map (fun m -> m.Manifest.Dependencies)
        |> Seq.append [state.Root]
        |> Seq.map (Set.map toPackageConstraint)
        |> Set.unionMany
        |> constraintsOf
  
      let c = cs |> All
      let candidates =
        state.Hints
        |> Map.tryFind p
        |> Option.defaultValue([])
        |> Seq.filter(fun lp -> lp.Versions |> Constraint.satisfies c)
        |> Seq.distinct
  
  
      let! request = resolver.PostAndAsyncReply (fun channel -> ProposeCandidates (constraints, (p, cs), candidates, channel))
      yield! request
    }
  
    let fetchHints (sourceExplorer : ISourceExplorer) (state: SolverState) (resolvedVersion : ResolvedVersion) : Async<SolverState> = async {
      try
  