Add missing map3/lift3 extensions (#403)

 Co-authored-by: pawel.zelmanski <pawel.zelmanski@ihsmarkit.com>

Author: 2 people

src/FSharpPlus/Control/Applicative.fs

@@ -109,8 +109,45 @@ type Lift2 with
 
  static member inline Lift2 (_, (_:'t when 't: null and 't: struct, _: ^u when ^u : null and ^u: struct), _mthd: Default1) = id
  static member inline Lift2 (f: 'T -> 'U -> 'V, (x: '``Applicative<'T>``, y: '``Applicative<'U>``) , _mthd: Default1) = ((^``Applicative<'T>`` or ^``Applicative<'U>`` ) : (static member Lift2 : _*_*_ -> _) f, x, y)
- 
 
+type Lift3 =
+ inherit Default1
+
+ static member Lift3 (f, (x: Lazy<_> , y: Lazy<_> , z: Lazy<_> ), _mthd: Lift3) = Lazy.map3 f x y z
+ static member Lift3 (f, (x: seq<_> , y: seq<_> , z: seq<_> ), _mthd: Lift3) = Seq.lift3 f x y z
+ static member Lift3 (f, (x: NonEmptySeq<_> , y: NonEmptySeq<_> , z: NonEmptySeq<_> ), _mthd: Lift3) = NonEmptySeq.lift3 f x y z
+  #if !FABLE_COMPILER
+ static member Lift3 (f, (x: IEnumerator<_> , y: IEnumerator<_> , z: IEnumerator<_> ), _mthd: Lift3) = Enumerator.map3 f x y z
+  #endif
+ static member Lift3 (f, (x , y , z ), _mthd: Lift3) = List.lift3 f x y z
+ static member Lift3 (f, (x , y , z ), _mthd: Lift3) = Array.lift3 f x y z
+ static member Lift3 (f, (x: 'R -> 'T , y: 'R -> 'U , z: 'R -> 'V ), _mthd: Lift3) = fun a -> f (x a) (y a) (z a)
+  #if !FABLE_COMPILER
+ static member Lift3 (f, (x: Task<'T> , y: Task<'U> , z: Task<'V> ), _mthd: Lift3) = Task.map3 f x y z
+  #endif
+ static member Lift3 (f, (x , y , z ), _mthd: Lift3) = Async.map3 f x y z
+ static member Lift3 (f, (x , y , z ), _mthd: Lift3) = Option.map3 f x y z
+ static member Lift3 (f, (x: Result<'T,'Error> , y: Result<'U,'Error> , z: Result<'V, 'Error> ), _mthd: Lift3) = Result.map3 f x y z
+ static member Lift3 (f, (x: Choice<'T,'Error> , y: Choice<'U,'Error> , z: Choice<'V, 'Error> ), _mthd: Lift3) = Choice.map3 f x y z
+ static member Lift3 (f, (x: Map<'Key,'T> , y: Map<'Key,'U> , z: Map<'Key, 'V> ), _mthd: Lift3) = Map.mapValues3 f x y z
+ static member Lift3 (f, (x: Dictionary<'Key,'T>, y: Dictionary<'Key,'U>, z: Dictionary<'Key, 'V>), _mthd: Lift3) = Dictionary.map3 f x y z
+  #if !FABLE_COMPILER
+ static member Lift3 (f, (x: Expr<'T> , y: Expr<'U> , z: Expr<'V> ), _mthd: Lift3) = <@ f %x %y %z @>
+  #endif
+ static member Lift3 (f, (x: ResizeArray<'T> , y: ResizeArray<'U> , z: ResizeArray<'V> ), _mthd: Lift3) = ResizeArray.lift3 f x y z
+
+ static member inline Invoke (f: 'T -> 'U -> 'V -> 'W) (x: '``Applicative<'T>``) (y: '``Applicative<'U>``) (z: '``Applicative<'V>``): '``Applicative<'W>`` =
+ let inline call (mthd : ^M, input1: ^I1, input2: ^I2, input3: ^I3, _output: ^R) =
+ ((^M or ^I1 or ^I2 or ^I3 or ^R) : (static member Lift3 : _*(_*_*_)*_ -> _) f, (input1, input2, input3), mthd)
+ call (Unchecked.defaultof<Lift3>, x, y, z, Unchecked.defaultof<'``Applicative<'W>``>)
+
+ static member inline InvokeOnInstance (f: 'T -> 'U -> 'V -> 'W) (x: '``Applicative<'T>``) (y: '``Applicative<'U>``) (z: '``Applicative<'V>``)=
+ ((^``Applicative<'T>`` or ^``Applicative<'U>`` or ^``Applicative<'V>``) : (static member Lift3 : _*_*_*_ -> _) f, x, y, z)
+
+type Lift3 with
+ static member inline Lift3 (f, (x, y, z), _mthd: Default3) = ((((Return.InvokeOnInstance f, x) ||> Apply.InvokeOnInstance), y) ||> Apply.InvokeOnInstance, z) ||> Apply.InvokeOnInstance
+ static member inline Lift3 (_, (_:'t when 't: null and 't: struct, _: ^u when ^u : null and ^u: struct, _: ^v when ^v : null and ^v: struct), _mthd: Default1) = id
+ static member inline Lift3 (f: 'T -> 'U -> 'V -> 'W, (x: '``Applicative<'T>``, y: '``Applicative<'U>``, z: '``Applicative<'V>``) , _mthd: Default1) = ((^``Applicative<'T>`` or ^``Applicative<'U>`` or ^``Applicative<'V>`` ) : (static member Lift3 : _*_*_*_ -> _) f, x, y, z)
 
 type IsLeftZero =
  inherit Default1

src/FSharpPlus/Data/NonEmptySeq.fs

@@ -501,6 +501,19 @@ module NonEmptySeq =
  let apply f x = bind (fun f -> map ((<|) f) x) f
 
  let lift2 f x1 x2 = allPairs x1 x2 |> map (fun (x, y) -> f x y)
+ 
+ /// <summary>Combines values from three NonEmptySeq and calls a mapping function on this combination.</summary>
+ /// <param name="f">Mapping function taking three element combination as input.</param>
+ /// <param name="x1">First NonEmptySeq.</param>
+ /// <param name="x2">Second NonEmptySeq.</param>
+ /// <param name="x3">Third NonEmptySeq.</param>
+ ///
+ /// <returns>NonEmptySeq with values returned from mapping function.</returns>
+ let lift3 f x1 x2 x3 =
+ allPairs x2 x3
+ |> allPairs x1
+ |> map (fun x -> (fst (snd x), snd (snd x), fst x))
+ |> map (fun (x, y, z) -> f x y z)
 
  let replace (oldValue: NonEmptySeq<'T>) (newValue: NonEmptySeq<'T>) (source: NonEmptySeq<'T>) : NonEmptySeq<'T> =
  Seq.replace oldValue newValue source |> unsafeOfSeq

src/FSharpPlus/Extensions/Array.fs

@@ -25,6 +25,21 @@ module Array =
  let lift2 f x y =
  let lenx, leny = Array.length x, Array.length y
  Array.init (lenx * leny) (fun i -> f x.[i / leny] y.[i % leny])
+ 
+ 
+ /// <summary>Combines all values from three arrays and calls a mapping function on this combination.</summary>
+ /// <param name="f">Mapping function taking three element combination as input.</param>
+ /// <param name="x1">First array.</param>
+ /// <param name="x2">Second array.</param>
+ /// <param name="x3">Third array.</param>
+ ///
+ /// <returns>Array with values returned from mapping function.</returns>
+ let lift3 f x y z =
+ let lenx, leny, lenz = Array.length x, Array.length y, Array.length z
+ let combinedFirstTwo = Array.init (lenx * leny) (fun i -> (x.[i / leny], y.[i % leny]))
+
+ Array.init (lenx * leny * lenz) (fun i -> combinedFirstTwo.[i/leny], z.[i%leny])
+ |> Array.map (fun x -> f (fst (fst x)) (snd (fst x)) (snd x))
 
  /// Concatenates all elements, using the specified separator between each element.
  let intercalate (separator: _ []) (source: seq<_ []>) = source |> Seq.intercalate separator |> Seq.toArray

src/FSharpPlus/Extensions/Async.fs

@@ -18,6 +18,18 @@ module Async =
  let! a = x
  let! b = y
  return f a b}
+ 
+ /// <summary>Creates an async workflow from three workflows 'x', 'y' and 'z', mapping its results with 'f'.</summary>
+ /// <remarks>Workflows are run in sequence.</remarks>
+ /// <param name="f">The mapping function.</param>
+ /// <param name="x">First async workflow.</param>
+ /// <param name="y">Second async workflow.</param>
+ /// <param name="z">third async workflow.</param>
+ let map3 f x y z = async {
+ let! a = x
+ let! b = y
+ let! c = z
+ return f a b c}
 
  /// <summary>Creates an async workflow from two workflows 'x' and 'y', tupling its results.</summary>
  let zip x y = async {

src/FSharpPlus/Extensions/Choice.fs

@@ -30,6 +30,19 @@ module Choice =
  /// <returns>The combined value, or the first Choice2Of2.</returns>
  let map2 f (x: Choice<'T,'Error>) (y: Choice<'U,'Error>) : Choice<'V,'Error> = match x, y with Choice1Of2 a, Choice1Of2 b -> Choice1Of2 (f a b) | Choice2Of2 e, _ | _, Choice2Of2 e -> Choice2Of2 e
 
+ /// <summary>Creates a Choice value from three of Choice values, using a function to combine the Choice1Of2 values.</summary>
+ /// <param name="x">The first Choice value.</param>
+ /// <param name="y">The second Choice value.</param>
+ /// <param name="z">The third Choice value.</param>
+ ///
+ /// <returns>The combined value, or the first Choice2Of2.</returns>
+ let map3 f (x: Choice<'T,'Error>) (y: Choice<'U,'Error>) (z: Choice<'V, 'Error>) : Choice<'W,'Error> =
+ match x, y, z with
+ | Choice1Of2 a, Choice1Of2 b, Choice1Of2 c -> Choice1Of2 (f a b c)
+ | Choice2Of2 e, _ , _
+ | _ , Choice2Of2 e, _
+ | _ , _ , Choice2Of2 e -> Choice2Of2 e
+
  /// <summary>Flattens two nested Choice.</summary>
  /// <param name="source">The nested Choice.</param>
  /// <returns>A single Choice1Of2 of the value when it was nested with Choice1Of2s, or the Choice2Of2.</returns>

src/FSharpPlus/Extensions/Dictionary.fs

@@ -73,6 +73,23 @@ module Dictionary =
  | Some vy -> dct.Add (k, f.Invoke (vx, vy))
  | None -> ()
  dct
+ 
+ /// <summary>Combines values from three Dictionaries using mapping function.</summary>
+ /// <remarks>Keys that are not present on every Dictionary are dropped.</remarks>
+ /// <param name="f">The mapping function.</param>
+ /// <param name="x">First input Dictionary.</param>
+ /// <param name="y">Second input Dictionary.</param>
+ /// <param name="y">Third input Dictionary.</param>
+ ///
+ /// <returns>The mapped Dictionary.</returns>
+ let map3 f (x: Dictionary<'Key, 'T1>) (y: Dictionary<'Key, 'T2>) (z: Dictionary<'Key, 'T3>) =
+ let dct = Dictionary<'Key, 'U> ()
+ let f = OptimizedClosures.FSharpFunc<_,_,_,_>.Adapt f
+ for KeyValue(k, vx) in x do
+ match tryGetValue k y, tryGetValue k z with
+ | Some vy, Some vz -> dct.Add (k, f.Invoke (vx, vy, vz))
+ | _ , _ -> ()
+ dct
 
  /// <summary>Applies given function to each value of the given dictionary.</summary>
  /// <param name="f">The mapping function.</param>

src/FSharpPlus/Extensions/Lazy.fs

@@ -9,6 +9,14 @@ module Lazy =
 
  /// <summary>Creates a Lazy value from a pair of Lazy values, using a mapping function to combine them.</summary>
  let map2 (mapping: 'T->'U->'V) (x: Lazy<'T>) (y: Lazy<'U>) = Lazy<_>.Create (fun () -> mapping x.Value y.Value)
+ 
+ /// <summary>Creates a Lazy value from three Lazy values, using a function to combine them.</summary>
+ /// <param name="x">The first Lazy value.</param>
+ /// <param name="y">The second Lazy value.</param>
+ /// <param name="z">The third Lazy value.</param>
+ ///
+ /// <returns>The combined value.</returns>
+ let map3 (f: 'T->'U->'V->'W) (x: Lazy<'T>) (y: Lazy<'U>) (z: Lazy<'V>) = Lazy<_>.Create (fun () -> f x.Value y.Value z.Value)
 
  /// <summary>Applies a Lazy value to a Lazy function.</summary>
  /// <param name="f">The Lazy function.</param>

src/FSharpPlus/Extensions/List.fs

@@ -30,6 +30,19 @@ module List =
 
  /// Combines all values from the first list with the second, using the supplied mapping function.
  let lift2 f x1 x2 = List.allPairs x1 x2 |> List.map (fun (x, y) -> f x y)
+ 
+ /// <summary>Combines values from three list and calls a mapping function on this combination.</summary>
+ /// <param name="f">Mapping function taking three element combination as input.</param>
+ /// <param name="x1">First list.</param>
+ /// <param name="x2">Second list.</param>
+ /// <param name="x3">Third list.</param>
+ ///
+ /// <returns>List with values returned from mapping function.</returns>
+ let lift3 f x1 x2 x3 =
+ List.allPairs x2 x3
+ |> List.allPairs x1
+ |> List.map (fun x -> (fst (snd x), snd (snd x), fst x))
+ |> List.map (fun (x, y, z) -> f x y z)
 
  /// Returns a list with all possible tails of the source list.
  let tails x = let rec loop = function [] -> [] | _::xs as s -> s::(loop xs) in loop x

src/FSharpPlus/Extensions/Map.fs

@@ -46,6 +46,21 @@ module Map =
  | Some vy -> yield (k, f.Invoke (vx, vy))
  | None -> () }
 
+ /// <summary>Combines values from three maps using mapping function.</summary>
+ /// <remarks>Keys that are not present on every Map are dropped.</remarks>
+ /// <param name="f">The mapping function.</param>
+ /// <param name="x">First input Map.</param>
+ /// <param name="y">Second input Map.</param>
+ /// <param name="y">Third input Map.</param>
+ ///
+ /// <returns>The mapped Map.</returns>
+ let mapValues3 f (x: Map<'Key, 'T1>) (y: Map<'Key, 'T2>) (z: Map<'Key, 'T3>) = Map <| seq {
+ let f = OptimizedClosures.FSharpFunc<_,_,_,_>.Adapt f
+ for KeyValue(k, vx) in x do
+ match Map.tryFind k y, lazy Map.tryFind k z with
+ | Some vy, Lazy (Some vz) -> yield (k, f.Invoke (vx, vy, vz))
+ | _ , _ -> () }
+ 
  /// <summary>Applies given function to each value of the given Map.</summary>
  /// <param name="f">The mapping function.</param>
  /// <param name="x">The input Map.</param>

src/FSharpPlus/Extensions/ResizeArray.fs

@@ -33,6 +33,16 @@ module ResizeArray =
  /// Combines all values from the first ResizeArray with the second, using the supplied mapping function.
  let lift2 mapping (x1: ResizeArray<'T>) (x2: ResizeArray<'U>) = ResizeArray (Seq.lift2 mapping x1 x2)
 
+ /// <summary>Combines values from three ResizeArrays and calls a mapping function on this combination.</summary>
+ /// <param name="f">Mapping function taking three element combination as input.</param>
+ /// <param name="x1">First ResizeArray.</param>
+ /// <param name="x2">Second ResizeArray.</param>
+ /// <param name="x3">Third ResizeArray.</param>
+ ///
+ /// <returns>ResizeArray with values returned from mapping function.</returns>
+ let lift3 mapping (x1: ResizeArray<'T>) (x2: ResizeArray<'U>) (x3: ResizeArray<'V>) =
+ ResizeArray (Seq.lift3 mapping x1 x2 x3)
+ 
  /// Concatenates all elements, using the specified separator between each element.
  let intercalate (separator: _ []) (source: seq<_ []>) = source |> Seq.intercalate separator |> Seq.toArray