anchor.diff:  // Checks wether a list of target platforms is supported by this path and with which penalty. 
   let getPenalty (requiredPlatforms:FrameworkIdentifier list) (path:string) =
       requiredPlatforms
  -    |> List.map (getPathPenalty path)
  -    |> List.sum
  +    |> List.sumBy (getPathPenalty path)
   
   let findBestMatch (paths : string list) (targetProfile : TargetProfile) = 
       let requiredPlatforms = 
  
positive.code:     if packagePlatform = targetPlatform then
          0
      else
          let penalties = targetPlatform.SupportedPlatforms
                          |> List.map (fun target -> getPlatformPenalty target packagePlatform)
          List.min (maxPenalty::penalties) + 1
  
  let getPathPenalty (path:string) (platform:FrameworkIdentifier) =
      if String.IsNullOrWhiteSpace path then
          maxPenalty - 1 // an empty path is considered compatible with every target, but with a high penalty so explicit paths are preferred
      else
          extractPlatforms path
          |> Array.map (getPlatformPenalty platform)
  
negative.code:         | PortableProfile(_, platforms) -> platforms
          | SinglePlatform(platform) -> [ platform ]
      
      let pathPenalties = 
          paths 
          |> List.map (fun path -> (path, getPenalty requiredPlatforms path))
      
      let minPenalty = 
          pathPenalties
          |> Seq.map snd
          |> Seq.min
  
      pathPenalties
      |> Seq.filter (fun (path, penalty) -> penalty = minPenalty && minPenalty < maxPenalty)
      |> Seq.map fst
      |> Seq.sortBy (fun path -> (extractPlatforms path).Length)
      |> Seq.tryFind (fun _ -> true)
  
  // For a given list of paths and target profiles return tuples of paths with their supported target profiles.
  // Every target profile will only be listed for own path - the one that best supports it. 
  let getSupportedTargetProfiles (paths : string list) =     
      TargetProfile.KnownTargetProfiles
      |> Seq.map (fun target -> findBestMatch paths target, target)
      |> Seq.collect (fun (path, target) -> 
             match path with
             | Some(p) -> [ (p, target) ]
             | _ -> [])
      |> Seq.groupBy fst
      |> Seq.map (fun (path, group) -> (path, Seq.map (fun (_, target) -> target) group))
      |> Map.ofSeq
  
  