Use map2

Author: gusty

src/FSharpPlus/Control/Applicative.fs

@@ -57,12 +57,7 @@ type Apply =
        dct
 
     static member        ``<*>`` (struct (f: IDictionary<'Key,_>, x: IDictionary<'Key,'T>) , _output: IDictionary<'Key,'U>  , [<Optional>]_mthd: Apply) : IDictionary<'Key,'U> =
-       let dct = Dictionary ()
-       for KeyValue(k, vf) in f do
-           match x.TryGetValue k with
-           | true, vx -> dct.Add (k, vf vx)
-           | _        -> ()
-       dct :> IDictionary<'Key,'U>
+       Dict.map2 id f x
 
     static member        ``<*>`` (struct (f: IReadOnlyDictionary<'Key,_>, x: IReadOnlyDictionary<'Key,'T>) , _output: IReadOnlyDictionary<'Key,'U>  , [<Optional>]_mthd: Apply) : IReadOnlyDictionary<'Key,'U> =
        let dct = Dictionary ()

src/FSharpPlus/Control/ZipApplicative.fs

@@ -29,8 +29,12 @@ type Pure =
         let inline call (mthd: ^M, output: ^R) = ((^M or ^R) : (static member Pure : _*_ -> _) output, mthd)
         call (Unchecked.defaultof<Pure>, Unchecked.defaultof<'``ZipApplicative<'T>``>) x
 
-    static member        Pure (_: seq<'a>         , _: Default2 ) = fun x -> Seq.initInfinite (fun _ -> x)         : seq<'a>    
-    static member        Pure (_: IEnumerator<'a> , _: Default2 ) = fun x -> Enumerator.upto None (fun _ -> x)     : IEnumerator<'a>
+    static member        Pure (_: seq<'a>         , _: Default4 ) = fun x -> Seq.initInfinite (fun _ -> x)         : seq<'a>
+    static member        Pure (_: IEnumerator<'a> , _: Default3 ) = fun x -> Enumerator.upto None (fun _ -> x)     : IEnumerator<'a>
+    static member        Pure (_: IDictionary<'k,'t>, _: Default2) = fun x -> Dict.initInfinite x: IDictionary<'k,'t>
+    #if (!FABLE_COMPILER_3) // TODO Dummy overload for now
+    static member        Pure (_: IReadOnlyDictionary<'k,'t>, _: Default3) = fun x -> readOnlyDict [Unchecked.defaultof<'k>, x] :  IReadOnlyDictionary<'k,'t>
+    #endif
     static member inline Pure (_: 'R              , _: Default1 ) = fun (x: 'T) -> Pure.InvokeOnInstance x    : 'R
     static member        Pure (x: Lazy<'a>        , _: Pure) = Return.Return (x, Unchecked.defaultof<Return>) : _ -> Lazy<'a>
     #if !FABLE_COMPILER

src/FSharpPlus/Extensions/Dict.fs

@@ -128,10 +128,18 @@ module Dict =
     ///
     /// <returns>The mapped dictionary.</returns>
     let map mapper (source: IDictionary<'Key, 'T>) =
-        let dct = Dictionary<'Key, 'U> ()
-        for KeyValue(k, v) in source do
-            dct.Add (k, mapper v)
-        dct :> IDictionary<'Key, 'U>
+        match source with
+        | :? DefaultableDict<'Key, 'T> as s ->
+            let dct = DefaultableDict<'Key, 'U> (mapper s.DefaultValue, Dictionary<'Key, 'U> ())
+            let dct = dct :> IDictionary<'Key, 'U>
+            for KeyValue(k, v) in source do
+                dct.Add (k, mapper v)
+            dct
+        | _ ->
+            let dct = Dictionary<'Key, 'U> ()
+            for KeyValue(k, v) in source do
+                dct.Add (k, mapper v)
+            dct :> IDictionary<'Key, 'U>
 
     /// <summary>Creates a Dictionary value from a pair of Dictionaries, using a function to combine them.</summary>
     /// <remarks>Keys that are not present on both dictionaries are dropped.</remarks>
@@ -141,13 +149,21 @@ module Dict =
     ///
     /// <returns>The combined dictionary.</returns>
     let map2 mapper (source1: IDictionary<'Key, 'T1>) (source2: IDictionary<'Key, 'T2>) =
-        let dct = Dictionary<'Key, 'U> ()
-        let f = OptimizedClosures.FSharpFunc<_, _, _>.Adapt mapper
-        for KeyValue(k, vx) in source1 do
-            match tryGetValue k source2 with
-            | Some vy -> dct.Add (k, f.Invoke (vx, vy))
-            | None    -> ()
-        dct :> IDictionary<'Key, 'U>
+        let map k1 k2 =
+            let dct = Dictionary<'Key, 'U> ()
+            let f = OptimizedClosures.FSharpFunc<_, _, _>.Adapt mapper
+            for k in set source1.Keys + set source2.Keys do
+                match tryGetValue k source1, tryGetValue k source2, k1, k2 with
+                | Some vx, Some vy, _      , _
+                | None   , Some vy, Some vx, _ 
+                | Some vx, None   , _      , Some vy -> dct.Add (k, f.Invoke (vx, vy))
+                | _      , _      , _      , _       -> ()
+            dct :> IDictionary<'Key, 'U>
+        match source1, source2 with
+        | (:? DefaultableDict<'Key,'T1> as s1), (:? DefaultableDict<'Key,'T2> as s2) -> initHybrid (mapper s1.DefaultValue s2.DefaultValue) (map (Some s1.DefaultValue) (Some s2.DefaultValue))
+        | (:? DefaultableDict<'Key,'T1> as s1), _ -> map (Some s1.DefaultValue) None
+        | _, (:? DefaultableDict<'Key,'T2> as s2) -> map None (Some s2.DefaultValue)
+        | _, _  -> map None None
 
     /// <summary>Combines values from three dictionaries using mapping function.</summary>
     /// <remarks>Keys that are not present on every dictionary are dropped.</remarks>
@@ -185,13 +201,7 @@ module Dict =
     /// <param name="source2">The second input dictionary.</param>
     ///
     /// <returns>The tupled dictionary.</returns>
-    let zip (source1: IDictionary<'Key, 'T1>) (source2: IDictionary<'Key, 'T2>) =
-        let dct = Dictionary<'Key, 'T1 * 'T2> ()
-        for KeyValue(k, vx) in source1 do
-            match tryGetValue k source2 with
-            | Some vy -> dct.Add (k, (vx, vy))
-            | None    -> ()
-        dct :> IDictionary<'Key, 'T1 * 'T2>
+    let zip (source1: IDictionary<'Key, 'T1>) (source2: IDictionary<'Key, 'T2>) = map2 (fun x y -> (x, y)) source1 source2
 
     /// <summary>Splits a dictionary with tuple pair values to two separate dictionaries.</summary>
     /// <param name="source">The source dictionary.</param>
@@ -223,6 +233,7 @@ module Dict =
         //     d :> IDictionary<'Key,'Value>
         match source1, source2 with
         | (:? DefaultableDict<'Key,'Value> as s1), (:? DefaultableDict<'Key,'Value> as s2) -> initHybrid (combiner s1.DefaultValue s2.DefaultValue) (combine())
+        | (:? DefaultableDict<'Key,'Value> as s), _ | _, (:? DefaultableDict<'Key,'Value> as s)  -> initHybrid s.DefaultValue (combine())
         | s, empty | empty, s when empty.Count = 0 -> s
         | _, _  -> combine()