anchor.diff:  /// that it mimics the intended function. They don't return a constant value.
   type IFlexQueryFunction = 
       abstract GetConstantResult : Constant list * Dictionary<string, IFlexQueryFunction> * Dictionary<string, string> option -> Result<string option>
  -    abstract GetVariableResult : FieldName * SearchQuery * Constant list * Dictionary<string, IFlexQueryFunction> * Dictionary<string, string> option -> Result<SearchQuery>
  +    abstract GetVariableResult : Field.T * FieldFunction * IFlexQuery * string [] -> Result<Query>
   
   
   [<AutoOpenAttribute>]
  
positive.code:     let inline queryNotFound queryName = QueryNotFound <| queryName
      let inline fieldNotFound fieldName = InvalidFieldName <| fieldName
  
      let handleFunctionValue 
          fName 
          parameters 
          (queryFunctionTypes : Dictionary<string, IFlexQueryFunction>) 
          (source : Dictionary<string,string> option) =
              match queryFunctionTypes.TryGetValue(fName) with
              | true, func -> 
                  match func.GetConstantResult(parameters, queryFunctionTypes, source) with
                  | Ok(r) -> ok <| r
                  | Fail(e) -> fail e
              | _ -> fail <| FunctionNotFound (sprintf "%A" <| Constant.Function(fName, parameters))
  
      // Gets a field from the given search profile.
      // Empty/blank values are considered an error
  
negative.code:                                        // we can ignore this condition, thus generate a matchall query
                                         | None -> generateMatchAllQuery := true; ok [||])
                  | _ -> fail <| SearchProfileUnsupportedFieldValue(fieldName)
              | None -> v |> computeFieldValueAsArray fieldName
          
          let queryGenerationWrapper fieldName operator constant parameters 
                                     (queryGetter : Field.T -> IFlexQuery -> string[] -> Result<Query>) =
              maybe {
                      // First validate the field
                      let! field = fieldName |> validateSearchField fields
                      // Then get the type of query operator being used
                      let! query = queryTypes |> keyExists (operator, queryNotFound)
                      // Then calculate the value of the constant expression on the RHS of the query
                      let! computedConstant = computeConstant (fieldName, constant)
                      
                      if generateMatchAllQuery.Value = true then return! ok <| getMatchAllDocsQuery()
                      else 
                          let! q = queryGetter field query computedConstant
  
                          // Apply boost if given
                          q.SetBoost(float32 <| doubleFromOptDict "boost" 1.0 parameters)
                          return q
                  }
  
          /// Generate the query from the CONSTANT condition
          /// This happens when the LHS of the query only has a field and no functions
          let getConstantCondition (fieldName, operator, constant : Constant, p) = 
              fun field (query : IFlexQuery) (computedConstant : string []) -> 
                  query.GetQuery(field, computedConstant.ToArray(), p)
              |> queryGenerationWrapper fieldName operator constant p
              
          /// Generate the query from the VARIABLE condition
          /// This happens when the LHS of the query has a function
          let getVariableCondition (fieldFunction : FieldFunction) operator constant p =
              match fieldFunction with 
              | FieldFunction(funcName, fieldName, prms) ->
                  let queryGetter field query computedConstant =
                      maybe {
                          // Get the appropriate LHS query function
                          let! fieldQueryFunc = funcName |> getQueryFunction queryFunctionTypes
                          // Compute the final query by analyzing the variable, operator and constant
                          return! fieldQueryFunc.GetVariableResult(field, fieldFunction, query, computedConstant)
                      }
  
                  queryGetter
                  |> queryGenerationWrapper fieldName operator constant p
  
          /// Main rec function responsible for generating predicate
          let rec generateQuery (pred : Predicate) = 
              maybe { 
  