Merge pull request #9528 from dotnet/merges/master-to-release/dev16.7

Merge master to release/dev16.7

Author: KevinRansom

src/fsharp/FSharp.Core/map.fs

@@ -218,6 +218,43 @@ module MapTree =
                     mk l sk sv r'
             else rebalance l k2 v2 (remove comparer k r) 
 
+    let rec change (comparer: IComparer<'Key>) k (u: 'Value option -> 'Value option) (m: MapTree<'Key, 'Value>) =
+        match m with
+        | MapEmpty ->
+            match u None with
+            | None -> m
+            | Some v -> MapOne (k, v)
+        | MapOne (k2, v2) ->
+            let c = comparer.Compare(k, k2)
+            if c < 0 then
+                match u None with
+                | None -> m
+                | Some v -> MapNode (k, v, MapEmpty, m, 2)
+            elif c = 0 then
+                match u (Some v2) with
+                | None -> MapEmpty
+                | Some v -> MapOne (k, v)
+            else
+                match u None with
+                | None -> m
+                | Some v -> MapNode (k, v, m, MapEmpty, 2)
+        | MapNode (k2, v2, l, r, h) ->
+            let c = comparer.Compare(k, k2)
+            if c < 0 then
+                rebalance (change comparer k u l) k2 v2 r
+            elif c = 0 then
+                match u (Some v2) with
+                | None ->
+                    match l, r with
+                    | MapEmpty, _ -> r
+                    | _, MapEmpty -> l
+                    | _ ->
+                        let sk, sv, r' = spliceOutSuccessor r
+                        mk l sk sv r'
+                | Some v -> MapNode (k, v, l, r, h)
+            else
+                rebalance l k2 v2 (change comparer k u r)
+
     let rec mem (comparer: IComparer<'Key>) k (m: MapTree<'Key, 'Value>) = 
         match m with 
         | MapEmpty -> false
@@ -512,6 +549,10 @@ type Map<[<EqualityConditionalOn>]'Key, [<EqualityConditionalOn; ComparisonCondi
 #endif
         new Map<'Key, 'Value>(comparer, MapTree.add comparer key value tree)
 
+    [<Experimental("Experimental library feature, requires '--langversion:preview'")>]
+    member m.Change(key, f) : Map<'Key, 'Value> =
+        new Map<'Key, 'Value>(comparer, MapTree.change comparer key f tree)
+
     [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
     member m.IsEmpty = MapTree.isEmpty tree
 
@@ -729,6 +770,11 @@ module Map =
     let add key value (table: Map<_, _>) =
         table.Add (key, value)
 
+    [<Experimental("Experimental library feature, requires '--langversion:preview'")>]
+    [<CompiledName("Change")>]
+    let change key f (table: Map<_, _>) =
+        table.Change (key, f)
+
     [<CompiledName("Find")>]
     let find key (table: Map<_, _>) =
         table.[key]

src/fsharp/FSharp.Core/map.fsi

@@ -22,6 +22,13 @@ namespace Microsoft.FSharp.Collections
         /// <returns>The resulting map.</returns>
         member Add: key:'Key * value:'Value -> Map<'Key,'Value>
 
+        /// <summary>Returns a new map with the value stored under key changed according to f.</summary>
+        /// <param name="key">The input key.</param>
+        /// <param name="f">The change function.</param>
+        /// <returns>The resulting map.</returns>
+        [<Experimental("Experimental library feature, requires '--langversion:preview'")>]
+        member Change: key:'Key * f:('Value option -> 'Value option) -> Map<'Key,'Value>
+
         /// <summary>Returns true if there are no bindings in the map.</summary>
         member IsEmpty: bool
 
@@ -86,6 +93,15 @@ namespace Microsoft.FSharp.Collections
         [<CompiledName("Add")>]
         val add: key:'Key -> value:'T -> table:Map<'Key,'T> -> Map<'Key,'T>
 
+        /// <summary>Returns a new map with the value stored under key changed according to f.</summary>
+        /// <param name="key">The input key.</param>
+        /// <param name="f">The change function.</param>
+        /// <param name="table">The input map.</param>
+        /// <returns>The resulting map.</returns>
+        [<Experimental("Experimental library feature, requires '--langversion:preview'")>]
+        [<CompiledName("Change")>]
+        val change: key:'Key -> f:('T option -> 'T option) -> table:Map<'Key,'T> -> Map<'Key,'T>
+
         /// <summary>Returns a new map made from the given bindings.</summary>
         /// <param name="elements">The input list of key/value pairs.</param>
         /// <returns>The resulting map.</returns>
@@ -263,4 +279,4 @@ namespace Microsoft.FSharp.Collections
 
         /// <summary>The number of bindings in the map.</summary>
         [<CompiledName("Count")>]
-        val count: table:Map<'Key,'T> -> int
+        val count: table:Map<'Key,'T> -> int

tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Collections/MapModule.fs

@@ -61,6 +61,40 @@ type MapModule() =
         Assert.AreEqual(resultExt.[2], "dup")   
 
 
+        ()
+
+    [<Test>]
+    member this.Change() =
+
+        let a = (Map.ofArray [|(1,1);(2,4);(3,9)|])
+        let b = Map.change 4 (fun current -> Assert.AreEqual(current, None); Some 16) a
+        Assert.AreEqual(b.[1], 1)
+        Assert.AreEqual(b.[2], 4)
+        Assert.AreEqual(b.[3], 9)
+        Assert.AreEqual(b.[4], 16)
+        let c = Map.change 4 (fun current -> Assert.AreEqual(current, Some 16); Some 25) b
+        Assert.AreEqual(b.[1], 1)
+        Assert.AreEqual(b.[2], 4)
+        Assert.AreEqual(b.[3], 9)
+        Assert.AreEqual(c.[4], 25)
+
+        // empty Map
+        let eptMap = Map.empty
+        let resultEpt = Map.change 1 (fun current -> Assert.AreEqual(current, None); Some "a") eptMap
+        Assert.AreEqual(resultEpt.[1], "a")
+
+        // One-element Map
+        let oeleMap = Map.ofSeq [(1, "one")]
+        let resultOele = Map.change 7 (fun current -> Assert.AreEqual(current, None); Some "seven") oeleMap
+        Assert.AreEqual(resultOele.[7], "seven")
+
+        // Remove element
+        let resultRm = Map.change 1 (fun current -> Assert.AreEqual(current, Some 1); None) c
+        Assert.IsFalse(resultRm.ContainsKey 1)
+        Assert.AreEqual(resultRm.[2], 4)
+        Assert.AreEqual(resultRm.[3], 9)
+        Assert.AreEqual(resultRm.[4], 25)
+
         ()
 
     [<Test>]

tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Collections/MapType.fs

@@ -246,6 +246,7 @@ type MapType() =
         let ae = e.Add(1,"Monday")
         Assert.AreEqual(ae.[1], "Monday")
 
+    [<Test>]
     member this.Add() =
 
         let a = (Map.ofArray [|(1,1);(2,4);(3,9)|])
@@ -256,6 +257,34 @@ type MapType() =
         let e  = Map.empty<int,string>
         let ae = e.Add(1,"Monday")
         Assert.AreEqual(ae.[1], "Monday")
+
+    [<Test>]
+    member this.Change() =
+
+        let a = (Map.ofArray [|(1,1);(2,4);(3,9)|])
+        let b = a.Change(4, fun current -> Assert.AreEqual(current, None); Some 16)
+        Assert.AreEqual(b.[1], 1)
+        Assert.AreEqual(b.[2], 4)
+        Assert.AreEqual(b.[3], 9)
+        Assert.AreEqual(b.[4], 16)
+        let c = b.Change(4, fun current -> Assert.AreEqual(current, Some 16); Some 25)
+        Assert.AreEqual(b.[1], 1)
+        Assert.AreEqual(b.[2], 4)
+        Assert.AreEqual(b.[3], 9)
+        Assert.AreEqual(c.[4], 25)
+
+        let e  = Map.empty<int,string>
+        let ue = e.Change(1, fun current -> Assert.AreEqual(current, None); Some "Monday")
+        Assert.AreEqual(ue.[1], "Monday")
+
+        let uo = ue.Change(1, fun current -> Assert.AreEqual(current, Some "Monday"); Some "Tuesday")
+        Assert.AreEqual(uo.[1], "Tuesday")
+
+        let resultRm = c.Change(1, fun current -> Assert.AreEqual(current, Some 1); None)
+        Assert.IsFalse(resultRm.ContainsKey 1)
+        Assert.AreEqual(resultRm.[2], 4)
+        Assert.AreEqual(resultRm.[3], 9)
+        Assert.AreEqual(resultRm.[4], 25)
 
     [<Test>]
     member this.ContainsKey() =

tests/FSharp.Core.UnitTests/SurfaceArea.coreclr.fs

@@ -218,6 +218,7 @@ Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count()
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue)
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey)
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]])
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString()
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey]
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey)
@@ -374,6 +375,7 @@ Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.F
 Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState)
 Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
 Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
 Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T])
 Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
 Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])

tests/FSharp.Core.UnitTests/SurfaceArea.net40.fs

@@ -218,6 +218,8 @@ Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count()
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue)
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey)
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]])
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString()
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey]
 Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey)
@@ -369,6 +371,7 @@ Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1
 Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
 Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
 Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
 Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
 Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
 Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState)