Merge branch 'master' into v1.6

Author: wallymathieu

docsrc/content/abstraction-zipapplicative.fsx

@@ -127,7 +127,7 @@ let arr2 = (+) <!> [|1;2;3|] <.> [|10;20;30|]
 
 // Validations
 
-let validated = app2 {
+let validated = applicative2' {
     let! x = async { return Ok 1 }
     and! y = async { return Ok 2 }
     and! z = async { return Error ["Error"] }

src/FSharpPlus.TypeLevel/Data/Matrix.fs

@@ -3,6 +3,7 @@ namespace FSharpPlus.Data
 #if !FABLE_COMPILER
 
 open System.Runtime.CompilerServices
+open System.ComponentModel
 open FSharpPlus.Control
 open FSharpPlus.TypeLevel
 open TypeLevelOperators
@@ -294,6 +295,13 @@ module Matrix =
     { Items =
         Array2D.init (Array2D.length1 m1.Items) (Array2D.length2 m1.Items)
           (fun i j -> f m1.Items.[i, j] m2.Items.[i, j] ) }
+
+  [<MethodImpl(MethodImplOptions.AggressiveInlining)>]
+  let map3 (f: 'a -> 'b -> 'c -> 'd) (m1: Matrix<'a, 'm, 'n>) (m2: Matrix<'b, 'm, 'n>) (m3: Matrix<'c, 'm, 'n>) : Matrix<'d, 'm, 'n> =
+    { Items =
+        Array2D.init (Array2D.length1 m1.Items) (Array2D.length2 m1.Items)
+          (fun i j -> f m1.Items.[i, j] m2.Items.[i, j] m3.Items.[i, j] ) }
+
   [<MethodImpl(MethodImplOptions.AggressiveInlining)>]
   let mapi (f: int -> int -> 'a -> 'b) (m: Matrix<'a, 'm, 'n>) : Matrix<'b, 'm, 'n> =
     { Items = Array2D.mapi (fun i j -> f i j) m.Items }
@@ -554,8 +562,17 @@ module Matrix =
 type Matrix<'Item, 'Row, 'Column> with
   static member inline Item (mtx: Matrix<'a, 'm, 'n>, (m, n)) = Matrix.get m n mtx
   static member inline Map  (mtx: Matrix<'a, 'm, 'n>, f: 'a -> 'b) = Matrix.map f mtx
+
+  [<EditorBrowsable(EditorBrowsableState.Never)>]
+  static member inline Map2 (f, m1, m2) : Matrix<'x, 'm, 'n> = Matrix.map2 f m1 m2
+
+  [<EditorBrowsable(EditorBrowsableState.Never)>]
+  static member inline Map3 (f, m1, m2, m3) : Matrix<'x, 'm, 'n> = Matrix.map3 f m1 m2 m3
+
   static member inline Return (x: 'x) : Matrix<'x, 'm, 'n> = Matrix.replicate Singleton Singleton x
+  static member inline Pure   (x: 'x) : Matrix<'x, 'm, 'n> = Matrix.replicate Singleton Singleton x
   static member inline ( <*> ) (f: Matrix<'x -> 'y, 'm, 'n>, x: Matrix<'x, 'm, 'n>) = Matrix.map2 id f x
+  static member inline ( <.> ) (f: Matrix<'x -> 'y, 'm, 'n>, x: Matrix<'x, 'm, 'n>) = Matrix.map2 id f x
   static member inline get_Zero () : Matrix<'a, 'm, 'n> = Matrix.zero
   static member inline ( + ) (m1, m2) = Matrix.map2 (+) m1 m2
   static member inline ( - ) (m1, m2) = Matrix.map2 (-) m1 m2
@@ -579,9 +596,21 @@ type Matrix<'Item, 'Row, 'Column> with
 type Vector<'Item, 'Length> with
   static member inline Item (v: Vector<'a, 'n>, i) = Vector.get i v
   static member inline Map (v: Vector<'a, 'n>, f: 'a -> 'b) : Vector<'b, 'n> = Vector.map f v
+  
+  [<EditorBrowsable(EditorBrowsableState.Never)>]
+  static member inline Map2 (f, vec1, vec2) : Vector<'x, 'n> = Vector.map2 f vec1 vec2
+
+  [<EditorBrowsable(EditorBrowsableState.Never)>]
+  static member inline Map3 (f, vec1, vec2, vec3) : Vector<'x, 'n> = Vector.map3 f vec1 vec2 vec3
+
   static member inline Return (x: 'x) : Vector<'x, 'n> = Vector.replicate Singleton x
+  static member inline Pure   (x: 'x) : Vector<'x, 'n> = Vector.replicate Singleton x
   static member inline ( <*> ) (f: Vector<'x -> 'y, 'n>, x: Vector<'x, 'n>) : Vector<'y, 'n> = Vector.apply f x
+  static member inline ( <.> ) (f: Vector<'x -> 'y, 'n>, x: Vector<'x, 'n>) : Vector<'y, 'n> = Vector.apply f x
+  
+  [<EditorBrowsable(EditorBrowsableState.Never)>]
   static member inline Zip (x, y) = Vector.zip x y
+
   static member inline get_Zero () : Vector<'x, 'n> = Vector.zero
   static member inline ( + ) (v1: Vector<_, 'n>, v2: Vector<_, 'n>) = Vector.map2 (+) v1 v2
   static member inline ( - ) (v1: Vector<_, 'n>, v2: Vector<_, 'n>) = Vector.map2 (-) v1 v2

src/FSharpPlus/Builders.fs

@@ -400,6 +400,16 @@ module GenericBuilders =
         member inline _.MergeSources3 (t1, t2, t3) : '``Applicative1<Applicative2<'T>>`` = (map3 >> map3) tuple3 t1 t2 t3
         member        _.Run x : '``Applicative1<Applicative2<'T>>`` = x
 
+    /// Generic 3 layers ZipApplicative CE builder.
+    type ZipApplicativeBuilder3<'``applicative1<applicative2<applicative3<'t>>>``> () =
+        member        _.ReturnFrom expr : '``applicative1<applicative2<applicative3<'t>>>`` = expr
+        member inline _.Return (x: 'T) : '``Applicative1<Applicative2<Applicative3<'T>>>`` = (pur >> pur >> pur) x
+        member inline _.Yield  (x: 'T) : '``Applicative1<Applicative2<Applicative3<'T>>>`` = (pur >> pur >> pur) x
+        member inline _.BindReturn (x: '``Applicative1<Applicative2<Applicative3<'T>>>``, [<InlineIfLambda>]f: _ -> _) : '``Applicative1<Applicative2<'U>>`` = (map >> map >> map) f x
+        member inline _.MergeSources  (t1, t2)     : '``Applicative1<Applicative2<Applicative3<'T>>>`` = (map2 >> map2 >> map2) tuple2 t1 t2
+        member inline _.MergeSources3 (t1, t2, t3) : '``Applicative1<Applicative2<Applicative3<'T>>>`` = (map3 >> map3 >> map3) tuple3 t1 t2 t3
+        member        _.Run x : '``Applicative1<Applicative2<Applicative3<'T>>>`` = x
+
     /// Creates a (lazy) monadic computation expression with side-effects (see http://fsprojects.github.io/FSharpPlus/computation-expressions.html for more information)
     let monad<'``monad<'t>``> = new MonadFxBuilder<'``monad<'t>``> ()
 
@@ -416,9 +426,12 @@ module GenericBuilders =
     let applicative3<'``Applicative1<Applicative2<Applicative3<'T>>>``> = ApplicativeBuilder3<'``Applicative1<Applicative2<Applicative3<'T>>>``> ()
 
     /// Creates a (non sequential) applicative computation expression.
-    let app<'``ZipApplicative<'T>``> = ZipApplicativeBuilder<'``ZipApplicative<'T>``> ()
+    let applicative'<'``ZipApplicative<'T>``> = ZipApplicativeBuilder<'``ZipApplicative<'T>``> ()
 
     /// Creates a (non sequential) applicative computation expression which compose effects of two Applicatives.
-    let app2<'``ZipApplicative1<ZipApplicative2<'T>>``> = ZipApplicativeBuilder2<'``ZipApplicative1<ZipApplicative2<'T>>``> ()
+    let applicative2'<'``ZipApplicative1<ZipApplicative2<'T>>``> = ZipApplicativeBuilder2<'``ZipApplicative1<ZipApplicative2<'T>>``> ()
+
+    /// Creates a (non sequential) applicative computation expression which compose effects of three Applicatives.
+    let applicative3'<'``Applicative1<Applicative2<Applicative3<'T>>>``> = ZipApplicativeBuilder3<'``Applicative1<Applicative2<Applicative3<'T>>>``> ()
 
 #endif

src/FSharpPlus/Operators.fs

@@ -54,6 +54,12 @@ module Operators =
     /// <category index="0">Common Combinators</category>
     let inline (/>) x = flip x
 
+    /// <summary>
+    /// Executes a side-effect function and returns the original input value. Same as 'tap' but with arguments flipped.
+    /// </summary>
+    /// <category index="0">Common Combinators</category>
+    let inline (|-) source ([<InlineIfLambda>]f: 'T -> unit) = f source; source
+
     /// <summary>
     /// Executes a side-effect function and returns the original input value.
     /// </summary>

tests/FSharpPlus.Tests/Applicatives.fs

@@ -20,7 +20,7 @@ module Applicatives =
 
     [<Test>]
     let zipApply () =        
-        let arr1 = app2 {
+        let arr1 = applicative2' {
             let! x1 = async { return [|1; 2; 3|] }
             and! x2 = async { return [|10; 20; 30|] }
             and! x3 = async { return [|100; 200; 300|] }