anchor.diff:      let valueList map = map |> Map.toList |> List.unzip |> snd
   
       /// Combines the two Maps into a single Map
  -    let union (loses: Map<_,_>) (wins: Map<_,_>) = 
  -        Seq.fold (fun m (KeyValue(k,v)) -> Map.add k v m) loses wins
  +    let inline union (loses: Map<'k, 'v>) (wins: Map<'k, 'v>) = 
  +        Map.fold (fun m k v -> Map.add k v m) loses wins
  +
  +    /// Combines the two Maps into a single Map, with custom decisioning on what happens in case of conflict
  +    let inline unionWith (decide : 'k -> 'v -> 'v -> 'v) (m1:Map<'k, 'v>) (m2:Map<'k, 'v>) =
  +        let inline add m k v1 =
  +            let v = match Map.tryFind k m with
  +                    | None    -> v1
  +                    | Some v2 -> decide k v1 v2
  +            Map.add k v m
  +        Map.fold add m1 m2
   
       let choose (f : 'T -> 'b -> 'c option) (map : Map<'T,'b>) =
           (Map.empty, map) ||> Map.fold (fun s k v -> 
  
positive.code:         choose chooser table
  
      /// Compares two maps for equality using the given comparison function, element by element.
      let inline equalsWith eq xs ys =
          let xs' = Map.toArray xs
          let ys' = Map.toArray ys
          Array.compareWith (fun x y -> if eq x y then 0 else 1) xs' ys' = 0
  
  
  #if FX_PORTABLE
  
negative.code: 
  /// Extensions for F#'s Map module.
  module Map =
      /// <summary>
      /// Returns a new map made from the given Dictionary (or anything else that implements <code>seq&lt;KeyValuePair&lt;&apos;a, &apos;b&gt;&gt;</code>).
      /// </summary>
      let ofDict (d:seq<KeyValuePair<'a, 'b>>) =
          d |> Seq.map (fun (KeyValue(x,y)) -> x, y) |> Map.ofSeq
  
      let spanWithKey pred map =
          map
          |> Map.fold (fun (l,r) k v ->
  