anchor.diff:              match newGroupF() with
               | Some newGroup -> { this with Groups = Map.add groupId newGroup this.Groups }
               | None -> this
  +
  +    member this.MapGroups(mapF) = { this with Groups = Map.map mapF this.Groups }
           
   
       member this.AddReference(framework : FrameworkIdentifier, lib : string, references) : InstallModel = 
  
positive.code:                         (fun _ -> Some(FrameworkGroup.singleton(framework,{ References = newFiles; ContentFiles = Set.empty }))))) this
      
      member this.UseLastInGroupAsFallback() = 
          let groups = 
              this.Groups |> Map.map (fun _ group -> { group with Fallbacks = (group.Frameworks |> Seq.last).Value })
          { this with Groups = groups
                      DefaultFallback = groups.[FrameworkIdentifier.DefaultGroup].Fallbacks }
      
      member this.DeleteIfGroupFallback() = 
          let groups = 
              this.Groups 
              |> Map.map (fun _ group -> 
                     let fallbacks = group.Fallbacks
                     { group with Frameworks = 
                                      group.Frameworks |> Seq.fold (fun frameworks kv -> 
                                                              let files = kv.Value
                                                              if files.References <> fallbacks.References then frameworks
                                                              else Map.remove kv.Key frameworks) group.Frameworks })
          { this with Groups = groups }
      
      member this.DeleteEmptyGroupIfDefaultFallback() = 
          let groups = 
              this.Groups 
              |> Map.map 
                     (fun _ group -> 
                     let fallbacks = group.Fallbacks
                     group.Frameworks 
                     |> Seq.fold (fun (group : FrameworkGroup) framework -> 
                            if framework.Value.References <> fallbacks.References then group
                            else { group with Frameworks = Map.remove framework.Key group.Frameworks }) group)
          { this with Groups = groups }
      
      member this.UsePortableVersionLibIfEmpty() = 
          this.GetFrameworks() 
  
negative.code:                 | Reference.Library lib -> not (lib.EndsWith ".dll" || lib.EndsWith ".exe")
                  | _ -> false ]
  
          this.MapGroups(fun _ group -> 
                                 { group with Frameworks = 
                                                  blackList 
                                                  |> List.fold 
  