renamed to batchMap

src/FSharp.Data.Adaptive/AdaptiveHashMap/AdaptiveHashMap.fs

@@ -756,9 +756,9 @@ module AdaptiveHashMapImplementation =
 
             HashMapDelta.ofHashMap changes
 
-    /// Reader for batchRecalc operations.
+    /// Reader for batchMap operations.
     [<Sealed>]
-    type BatchRecalculateDirty<'k, 'a, 'b>(input : amap<'k, 'a>, mapping : HashMap<'k,'a> -> HashMap<'k, aval<'b>>) =
+    type BatchMap<'k, 'a, 'b>(input : amap<'k, 'a>, mapping : HashMap<'k,'a> -> HashMap<'k, aval<'b>>) =
         inherit AbstractReader<HashMapDelta<'k, 'b>>(HashMapDelta.empty)
 
         let reader = input.GetReader()
@@ -1415,17 +1415,17 @@ module AMap =
         else
             create (fun () -> MapAReader(map, mapping))
 
-    /// Adaptively applies the given mapping to all changes and reapplies mapping on dirty outputs
-    let batchRecalcDirty (mapping: HashMap<'K, 'T1> -> HashMap<'K, aval<'T2>>) (map: amap<'K, 'T1>) =
+    /// Adaptively applies the given mapping to batches of all changes and reapplies mapping on dirty outputs
+    let batchMap (mapping: HashMap<'K, 'T1> -> HashMap<'K, aval<'T2>>) (map: amap<'K, 'T1>) =
         if map.IsConstant then
             let map = force map |> mapping
             if map |> HashMap.forall (fun _ v -> v.IsConstant) then
                 constant (fun () -> map |> HashMap.map (fun _ v -> AVal.force v))
             else
                 // TODO better impl possible
-                create (fun () -> BatchRecalculateDirty(ofHashMap map, id))
+                create (fun () -> BatchMap(ofHashMap map, id))
         else
-            create (fun () -> BatchRecalculateDirty(map, mapping))
+            create (fun () -> BatchMap(map, mapping))
 
 
     /// Adaptively chooses all elements returned by mapping.  

src/FSharp.Data.Adaptive/AdaptiveHashMap/AdaptiveHashMap.fsi

@@ -105,8 +105,8 @@ module AMap =
     /// Adaptively applies the given mapping function to all elements and returns a new amap containing the results.
     val mapA : mapping: ('K -> 'V -> aval<'T>) -> map: amap<'K, 'V> -> amap<'K, 'T>
 
-    /// Adaptively applies the given mapping to all changes.
-    val batchRecalcDirty : mapping: (HashMap<'K,'T1> -> HashMap<'K,aval<'T2>>) -> map: amap<'K, 'T1> -> amap<'K, 'T2>
+    /// Adaptively applies the given mapping to batches of all changes and reapplies mapping on dirty outputs
+    val batchMap : mapping: (HashMap<'K,'T1> -> HashMap<'K,aval<'T2>>) -> map: amap<'K, 'T1> -> amap<'K, 'T2>
 
     /// Adaptively chooses all elements returned by mapping.  
     val chooseA : mapping: ('K -> 'V -> aval<option<'T>>) -> map: amap<'K, 'V> -> amap<'K, 'T>

src/FSharp.Data.Adaptive/AdaptiveValue/AdaptiveValue.fs

@@ -408,7 +408,7 @@ module AVal =
     /// Additionally fsproj files have dependencies, such as project.assets.json, that can't be determined until loaded with msbuild 
     /// but should be reloaded if those dependent files change. 
     /// </remarks>
-    let mapWithAdditionalDependencies (mapping: 'a -> 'b * seq<#IAdaptiveValue>) (value: aval<'a>) : aval<'b> =
+    let mapWithAdditionalDependencies (mapping: 'a -> 'b * #seq<#IAdaptiveValue>) (value: aval<'a>) : aval<'b> =
         let mutable lastDeps = HashSet.empty
 
         { new AbstractVal<'b>() with

src/FSharp.Data.Adaptive/AdaptiveValue/AdaptiveValue.fsi

@@ -116,7 +116,7 @@ module AVal =
     /// Additionally fsproj files have dependencies, such as project.assets.json, that can't be determined until loaded with msbuild 
     /// but should be reloaded if those dependent files change. 
     /// </remarks>
-    val mapWithAdditionalDependencies : mapping :( 'T1 -> 'T2 * seq<#IAdaptiveValue>) -> value: aval<'T1> -> aval<'T2> 
+    val mapWithAdditionalDependencies : mapping :( 'T1 -> 'T2 * #seq<#IAdaptiveValue>) -> value: aval<'T1> -> aval<'T2> 
 
     /// Returns a new adaptive value that adaptively applies the mapping function to the given 
     /// input and adaptively depends on the resulting adaptive value.

src/Test/FSharp.Data.Adaptive.Tests/AMap.fs

@@ -651,11 +651,11 @@ module AMap =
             >> HashMap.map(fun _ v ->
             AVal.constant v |> AVal.mapWithAdditionalDependencies (id)
             )
-        AMap.batchRecalcDirty mapping map
+        AMap.batchMap mapping map
 
 
 [<Test>]
-let ``[AMap] batchRecalcDirty``() =
+let ``[AMap] batchMap``() =
 
     let file1 = "File1.fs"
     let file1Cval = cval 1