Merge branch 'fable-3' of https://github.com/delneg/FSharp.Data.Adaptive into fable-3

Author: krauthaufen

RELEASE_NOTES.md

@@ -1,3 +1,6 @@
+### 1.2.2
+* added [HashMap|HashSet|IndexList] computeDeltaCustom
+
 ### 1.2.1
 * ShallowEquality now descends into non-recursive DUs (e.g. option)
 

src/FSharp.Data.Adaptive/Datastructures/Deltas.fs

@@ -7,6 +7,11 @@ module DifferentiationExtensions =
     /// Functional programming operators related to the HashSet<_> type.
     module HashSet =
 
+        /// Determines the operations needed to transform l into r, using custom element operation functions.
+        /// Returns a HashSetDelta containing these operations.
+        let computeDeltaCustom (l: HashSet<'T>) (r: HashSet<'T>) (add : 'T -> bool) (remove : 'T -> bool) =
+            l.ComputeDeltaAsHashMap(r, remove, add) |> HashSetDelta
+
         /// Determines the operations needed to transform l into r.
         /// Returns a HashSetDelta containing these operations.
         let computeDelta (l: HashSet<'T>) (r: HashSet<'T>) =
@@ -43,15 +48,13 @@ module DifferentiationExtensions =
     /// Functional programming operators related to the HashMap<_,_> type.
     module HashMap =
 
-        /// Determines the operations needed to transform l into r.
+        /// Determines the operations needed to transform l into r, using custom element operation functions.
         /// Returns a HashMapDelta containing all the needed operations.
-        let computeDelta (l: HashMap<'A, 'B>) (r: HashMap<'A, 'B>): HashMapDelta<'A, 'B> =
-            let inline add (_k : 'A) (v : 'B) = ValueSome (Set v)
-            let inline remove (_k : 'A) (v : 'B) = ValueSome Remove
-            let inline update (_k : 'A) (o : 'B) (n : 'B) =
-                if DefaultEquality.equals o n then ValueNone
-                else ValueSome (Set n)
-
+        let computeDeltaCustom 
+            (add: 'A -> 'B -> ValueOption<ElementOperation<'B>>) 
+            (remove: 'A -> 'B -> ValueOption<ElementOperation<'B>>) 
+            (update: 'A -> 'B -> 'B -> ValueOption<ElementOperation<'B>>)
+            (l: HashMap<'A, 'B>) (r: HashMap<'A, 'B>): HashMapDelta<'A, 'B> =
             let delta = 
                 HashImplementation.MapNode.computeDelta 
                     l.Comparer
@@ -63,6 +66,16 @@ module DifferentiationExtensions =
 
             HashMap<'A, ElementOperation<'B>>(l.Comparer, delta) |> HashMapDelta
 
+        /// Determines the operations needed to transform l into r.
+        /// Returns a HashMapDelta containing all the needed operations.
+        let computeDelta (l: HashMap<'A, 'B>) (r: HashMap<'A, 'B>): HashMapDelta<'A, 'B> =
+            let inline add (_k : 'A) (v : 'B) = ValueSome (Set v)
+            let inline remove (_k : 'A) (v : 'B) = ValueSome Remove
+            let inline update (_k : 'A) (o : 'B) (n : 'B) =
+                if DefaultEquality.equals o n then ValueNone
+                else ValueSome (Set n)
+            computeDeltaCustom add remove update l r
+
         let applyDelta (l : HashMap<'K, 'V>) (r : HashMapDelta<'K, 'V>) =
             let inline apply (_ : 'K) (o : voption<'V>) (n : ElementOperation<'V>) =
                 match n with
@@ -90,8 +103,8 @@ module DifferentiationExtensions =
     /// Functional programming operators related to the IndexList<_> type.
     module IndexList =
 
-        /// Determines the operations needed to transform l into r.
-        /// Returns a IndexListDelta containing these operations.
+        /// Applies the given operations to the list. 
+        /// Returns the new list and the 'effective' operations.
         let applyDelta (x : IndexList<'T>) (deltas : IndexListDelta<'T>) =
             let inline apply _ o n =
                 match n with
@@ -108,14 +121,23 @@ module DifferentiationExtensions =
                         struct(ValueSome v, ValueSome (Set v))
             let s, d = x.Content.ApplyDeltaAndGetEffective(deltas.Content, apply)
             IndexList.ofMap s, IndexListDelta.ofMap d
-
-        /// Applies the given operations to the list. 
+            
+        /// Applies the given operations to the list, using custom element operation functions. 
         /// Returns the new list and the 'effective' operations.
+        let computeDeltaCustom 
+            (add: Index -> 'T -> ElementOperation<'T>) 
+            (remove: Index -> 'T -> ElementOperation<'T>) 
+            (update: Index -> 'T -> 'T -> ValueOption<ElementOperation<'T>>)
+            (l : IndexList<'T>) (r : IndexList<'T>) : IndexListDelta<'T> =
+            let res = l.Content.ComputeDeltaTo(r.Content, add, update, remove)
+            IndexListDelta res
+
+        /// Determines the operations needed to transform l into r.
+        /// Returns a IndexListDelta containing these operations.
         let computeDelta (l : IndexList<'T>) (r : IndexList<'T>) : IndexListDelta<'T> =
             let inline add _ v = Set v
             let inline rem _ _ = Remove
             let inline update _ o n =
                 if DefaultEquality.equals o n then ValueNone
                 else ValueSome (Set n)
-            let res = l.Content.ComputeDeltaTo(r.Content, add, update, rem)
-            IndexListDelta res
+            computeDeltaCustom add rem update l r

src/FSharp.Data.Adaptive/Datastructures/HashCollections.fs

@@ -3383,6 +3383,13 @@ type HashSet<'K> internal(comparer : IEqualityComparer<'K>, root : SetNode<'K>)
         let delta = SetNode.computeDelta comparer remOp addOp root other.Root
         HashMap<'K, int>(comparer, delta)
 
+    [<MethodImpl(MethodImplOptions.AggressiveInlining)>]
+    member x.ComputeDeltaAsHashMap(other : HashSet<'K>, remOp : 'K -> bool, addOp : 'K -> bool) =
+        let rem = fun k -> if remOp k then ValueSome -1 else ValueNone
+        let add = fun k -> if addOp k then ValueSome  1 else ValueNone
+        let delta = SetNode.computeDelta comparer rem add root other.Root
+        HashMap<'K, int>(comparer, delta)
+
     [<MethodImpl(MethodImplOptions.AggressiveInlining)>]
     member x.ApplyDeltaAsHashMap(delta : HashMap<'K, int>) =
         let state = root

src/FSharp.Data.Adaptive/FableHelpers.fs

@@ -101,29 +101,9 @@ module OptimizedClosures =
 
 namespace System.Runtime.CompilerServices
 
-
-[<AutoOpen>]
-module private WeakTableHelpers =
-    open Fable.Core
-    open Fable.Core.JsInterop
-
-    type [<AllowNullLiteral>] WeakMap<'K, 'V> =
-        interface
-            abstract clear: unit -> unit
-            abstract delete: key: 'K -> bool
-            abstract get: key: 'K -> 'V
-            abstract has: key: 'K -> bool
-            abstract set: key: 'K * ?value: 'V -> WeakMap<'K, 'V>
-        end
-
-    and [<AllowNullLiteral>] WeakMapConstructor =
-        [<Emit("new $0($1...)")>] abstract Create: ?iterable: seq<'K * 'V> -> WeakMap<'K, 'V>
-
-    let [<Global>] WeakMap: WeakMapConstructor = jsNative
-
 type ConditionalWeakTable<'K, 'V when 'K : not struct and 'V : not struct>() =
 
-    let m = WeakMap.Create<'K, 'V> []
+    let m = Fable.Core.JS.WeakMap.Create<'K, 'V> []
 
     member x.TryGetValue(key : 'K) =
         if m.has key then (true, m.get key)