anchor.diff:  
     let constraintsOfSelection selections =
       Map.valueList selections
  -      |> List.map (fun m -> m.Manifest.Dependencies)
  -      |> List.map (Set.map toPackageConstraint)
  -      |> List.fold Set.union Set.empty
  +      |> Seq.map (fun m -> m.Manifest.Dependencies)
  +      |> Seq.map (Set.map toPackageConstraint)
  +      |> Seq.fold Set.union Set.empty
         |> constraintsOf
   
   
  
positive.code:         |> AsyncSeq.mapAsync(fun candidate -> async {
            match candidate with
            | Result.Error e ->
              return Result.Error e
            | Result.Ok (_, (location, versions)) ->
              let! lock = sourceExplorer.LockLocation location
  
negative.code: 
    type ResolutionRequest =
    | MarkBadPath of List<ResolutionPath> * PackageConstraint * SearchStrategyError * AsyncReplyChannel<Unit>
    | ProposeCandidates of Constraints * PackageConstraint * seq<LockedPackage> * AsyncReplyChannel<AsyncSeq<Result<ResolvedVersion, SearchStrategyError>>>
    | GetCandidates of Constraints * PackageConstraint * PackageSources * AsyncReplyChannel<AsyncSeq<Result<(PackageIdentifier * LocatedVersionSet), SearchStrategyError>>>
  
    type SearchStrategy = ISourceExplorer -> SolverState -> AsyncSeq<Result<PackageIdentifier * LocatedVersionSet, SearchStrategyError>>
  
    let private ifError x =
      match x with
      | Result.Error e -> Some e
      | _ -> None
  
    let private ifOk x =
      match x with
      | Result.Ok v -> Some v
      | _ -> None
  
    let private resultOrDefaultWith f x =
      match x with
      | Result.Ok v -> v
      | Result.Error e -> f e
  
    let toDnf c =
      match c with
  