anchor.diff:                      | Some ndx -> (op,k,ndx,[| v |]) |> Some
                       | None -> None
           ) comps
  +
  +    let private findFitIndexes indexes m =
  +        let textQuery = findTextQuery m
  +        let comps = findUsableCompares m
  +        Array.choose (fun ndx ->
  +            match tryFitIndexToQuery ndx comps textQuery with
  +            | Some fit -> (ndx, fit) |> Some
  +            | None -> None
  +        ) indexes
   
       let private chooseFromPossibles possibles =
           if Array.isEmpty possibles then 
  
positive.code:                         if num_comps > num_eq then
                              // we will have one inequality
                              let ineq = matching_comps.[num_eq]
                              if num_eq>0 then
                                  (Some matching_eqs, Some ineq, None) |> Some
                              else
  
negative.code:                 else
                      // we have some scalar keys, and maybe a text index after it.
                      // for every scalar key, find comparisons from the query.
                      let matching_comps = Array.map (fun (k,_) -> Array.choose (fun (op,km,v) -> if k=km then Some (op,v) else None) comps) scalar_keys
                      let first_no_comps = Array.tryFindIndex (fun acomps -> 0 = Array.length acomps) matching_comps
                      let matching_eqs = Array.map (fun acomps -> Array.choose (fun (op,v) -> if op=plan.EQ then Some v else None) acomps) matching_comps
                      let first_no_eqs = Array.tryFindIndex (fun acomps -> 0 = Array.length acomps) matching_eqs
  
                      // fail if our matcher has something like 
                      // (a=3) && (a=5)
                      // TODO this seems like the wrong place to do this check.
                      // and we should be doing other checks, like
                      // (a<0) && (a>0)
                      // or
                      // (a=5) && (a<4)
                      // and we should maybe eliminate redundant checks like
                      // (a<4) && (a<7)
                      // but still, this seems like the wrong place for this.
                      // because if it's here, then it will get checked on every
                      // index.  and if there are no indexes, it won't get checked
                      // at all.
  
                      if Array.exists (fun acomps -> 
                          let distinct = acomps |> Set.ofArray |> Set.toArray
                          (Array.length distinct > 1)
                      ) matching_eqs then
                          failwith "matcher has something eq multiple different values"
  
                      let matching_eqs = Array.map (fun acomps -> Array.get acomps 0) matching_eqs
  
                      match textQuery with
                      | Some _ ->
                          match first_no_eqs with
                          | Some _ ->
                              // if there is a text index, we need an EQ for every scalar key.
  