anchor.diff:                  ((procInner.Model, Map.empty), procInner.Bindings)
                   ||> Map.fold (
                       fun (current, prevBinders) var valueBinder ->
  -                        match valueBinder with
  -                        | BaseValueBinder _ ->
  -                            current, prevBinders |> Map.add var valueBinder
  -                        | _ ->
  -                            sprintf "%A not yet supported for DISTINCT alignment" valueBinder
  -                            |> NotImplementedException
  -                            |> raise
  +                        addValueBinderToDistinctModel typeIndexer current prevBinders var valueBinder
                   )
                   |> fun (innerModel, bindings) ->
                       {
  
positive.code:             Variables = valueBindings |> Map.keys |> List.ofSeq
          }
  
  let private applyModifiers (typeIndexer: TypeIndexer) (modifiers: Modifier list) (inner: BoundCalculusModel) =
      (inner, modifiers)
      ||> List.fold (
  
negative.code: 
      valueBinders, joinConditions
  
  let private getNotModifiedModel model =
      match model with
      | NotModified notModified ->
          notModified
      | _ ->
          { Sources = SubQuery model |> List.singleton; Assignments = List.empty; Filters = List.empty }
  
  let private applyOnNotModifiedModel applyFunction model =
      model
      |> getNotModifiedModel
      |> applyFunction
      |> NotModified
      |> optimizeCalculusModel
  
  let rec private processSparqlPattern (database: ISqlDatabaseSchema) (typeIndexer: TypeIndexer) (sparqlPattern: SparqlPattern) =
      optimizeBoundCalculusModel <|
      match sparqlPattern with
      | EmptyPattern -> 
  