anchor.diff:      }
   
   
  -let dep (p : string, vs : List<Version>) : Buckaroo.Dependency = {
  +let dep (p : string, c: Constraint) : Buckaroo.Dependency = {
       Package = package p;
  -    Constraint = Any ( vs |> List.map (Exactly));
  +    Constraint = c;
       Targets = None
   }
   
  
positive.code: 
      Buckaroo.Solver.solve context root style None
  
  let inSolution (r: Resolution) (p : string, v : int) =
    match r with
    | Ok solution ->
      let (resolved, _) = solution.Resolutions.[package p]
      System.Console.WriteLine resolved
      resolved.Versions |> Set.contains (rev v)
    | _ -> false
  ()
  
  [<Fact>]
  let ``Solver handles simple case`` () =
    let spec = [
      (package "a", ver 2, manifest [("b", [ver 1])])
      (package "a", ver 1, manifest [("b", [ver 1])])
      (package "b", ver 1, manifest [])
    ]
  
    let root = manifest [("a", [branch ""])]
    let r = solve spec ResolutionStyle.Quick root
            |> Async.RunSynchronously
  
    Assert.True (("a", 2) |> inSolution r)
    Assert.True (("b", 1) |> inSolution r)
  
    ()
negative.code:     with Dependencies = xs |> List.map dep |> Set.ofList
  }
  
  type ManifestSpec = List<PackageIdentifier * Set<Version> * Manifest>
  
  let solve (manifests : ManifestSpec) style root =
      let console = new ConsoleManager(LoggingLevel.Debug);
  