Merge branch 'master' into v1.3

Author: wallymathieu

src/FSharpPlus/Builders.fs

@@ -341,7 +341,7 @@ module GenericBuilders =
         #endif
         member inline _.MergeSources  (t1: '``Applicative<'T>``, t2: '``Applicative<'U>``) : '``Applicative<'T * 'U>`` = Lift2.Invoke tuple2 t1 t2
         member inline _.MergeSources3 (t1: '``Applicative<'T>``, t2: '``Applicative<'U>``, t3: '``Applicative<'V>``) : '``Applicative<'T * 'U * 'V>`` = Lift3.Invoke tuple3 t1 t2 t3
-        member        _.Run f = f : '``applicative<'t>``
+        member        _.Run f = f : '``Applicative<'T>``
 
     /// Generic 2 layers Applicative CE builder.
     type ApplicativeBuilder2<'``applicative1<applicative2<'t>>``> () =
@@ -355,7 +355,7 @@ module GenericBuilders =
         #endif
         member inline _.MergeSources  (t1, t2)     : '``Applicative1<Applicative2<'T>>`` = (lift2 >> lift2) tuple2 t1 t2
         member inline _.MergeSources3 (t1, t2, t3) : '``Applicative1<Applicative2<'T>>`` = (lift3 >> lift3) tuple3 t1 t2 t3
-        member        _.Run x : '``applicative1<applicative2<'t>>`` = x
+        member        _.Run x : '``Applicative1<Applicative2<'T>>`` = x
 
     /// Generic 3 layers Applicative CE builder.
     type ApplicativeBuilder3<'``applicative1<applicative2<applicative3<'t>>>``> () =
@@ -369,7 +369,7 @@ module GenericBuilders =
         #endif
         member inline _.MergeSources  (t1, t2)     : '``Applicative1<Applicative2<Applicative3<'T>>>`` = (lift2 >> lift2 >> lift2) tuple2 t1 t2
         member inline _.MergeSources3 (t1, t2, t3) : '``Applicative1<Applicative2<Applicative3<'T>>>`` = (lift3 >> lift3 >> lift3) tuple3 t1 t2 t3
-        member        _.Run x : '``applicative1<applicative2<applicative3<'t>>>`` = x
+        member        _.Run x : '``Applicative1<Applicative2<Applicative3<'T>>>`` = x
 
 
 

src/FSharpPlus/Data/Validation.fs

@@ -84,21 +84,21 @@ module Validation =
             -> Failure (e1 + e2)
             #endif
 
-    let inline foldBack (folder: 'T->'State->'State) (source: Validation<'Error,'T>) (state: 'State) =
+    let inline foldBack (folder: 'T -> 'State -> 'State) (source: Validation<'Error, 'T>) (state: 'State) =
         match source with
         | Success a -> folder a state
         | Failure _ -> state
 
     #if !FABLE_COMPILER || FABLE_COMPILER_3
 
     /// Traverse the Success case with the supplied function.
-    let inline traverse (f: 'T->'``Functor<'U>``) (source: Validation<'Error,'T>) : '``Functor<Validation<'Error,'U>>`` =
+    let inline traverse (f: 'T -> '``Functor<'U>``) (source: Validation<'Error, 'T>) : '``Functor<Validation<'Error, 'U>>`` =
         match source with
         | Success a -> Validation<'Error,'U>.Success <!> f a
         | Failure e -> result (Validation<'Error,'U>.Failure e)
 
     /// Traverse the Success case.
-    let inline sequence (source: Validation<'Error,'``Functor<'T>``>) : '``Functor<Validation<'Error,'T>>`` = traverse id source
+    let inline sequence (source: Validation<'Error, '``Functor<'T>``>) : '``Functor<Validation<'Error, 'T>>`` = traverse id source
 
     #endif
 
@@ -245,11 +245,11 @@ module Validation =
     #endif
 
 
-type Validation<'err,'a> with
+type Validation<'error, 't> with
 
     // as Applicative
     static member Return x = Success x
-    static member inline (<*>)  (f: Validation<_,'T->'U>, x: Validation<_,'T>) : Validation<_,_> = Validation.apply f x
+    static member inline (<*>)  (f: Validation<'Error, 'T -> 'U>, x: Validation<_, 'T>) : Validation<_, _> = Validation.apply f x
 
     /// <summary>
     /// Sequences two Validations left-to-right, discarding the value of the first argument.
@@ -264,39 +264,39 @@ type Validation<'err,'a> with
     static member inline (<*  ) (x: Validation<'Error, 'U>, y: Validation<'Error, 'T>): Validation<'Error, 'U> = ((fun (k: 'U) (_: 'T) -> k ) </Validation.map/> x : Validation<'Error, 'T->'U>) </Validation.apply/> y
 
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member inline Lift2 (f, x: Validation<_,'T>, y: Validation<_,'U>) : Validation<_,'V> = Validation.map2 f x y
+    static member inline Lift2 (f, x: Validation<'Error, 'T>, y: Validation<'Error, 'U>) : Validation<'Error, 'V> = Validation.map2 f x y
 
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member inline Lift3 (f, x: Validation<_,'T>, y: Validation<_,'U>, z: Validation<_,'V>) : Validation<_,'W> = Validation.map3 f x y z
+    static member inline Lift3 (f, x: Validation<'Error, 'T>, y: Validation<_, 'U>, z: Validation<_, 'V>) : Validation<_, 'W> = Validation.map3 f x y z
 
-    #if !FABLE_COMPILER || FABLE_COMPILER_3
     // as Alternative (inherits from Applicative)
+    #if !FABLE_COMPILER || FABLE_COMPILER_3
     static member inline get_Empty () = Failure (getEmpty ())
-    static member inline (<|>) (x: Validation<_,_>, y: Validation<_,_>) = Validation.appValidation Control.Append.Invoke x y
+    static member inline (<|>) (x: Validation<'Error, 'T>, y: Validation<_,_>) = Validation.appValidation Control.Append.Invoke x y
     #endif
 
     // as Functor
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member Map (x: Validation<_,_>, f) = Validation.map f x
+    static member Map (x: Validation<'Error, _>, f: 'T -> 'U) = Validation.map f x
 
     /// <summary>Lifts a function into a Validator. Same as map.
     /// To be used in Applicative Style expressions, combined with &lt;*&gt;
     /// </summary>
     /// <category index="1">Functor</category>
-    static member (<!>) (f, x: Validation<_,_>) = Validation.map f x
+    static member (<!>) (f: 'T -> 'U, x: Validation<'Error, _>) = Validation.map f x
 
     // as Bifunctor
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member Bimap (x: Validation<'T,'V>, f: 'T->'U, g: 'V->'W) : Validation<'U,'W> = Validation.bimap f g x
+    static member Bimap (x: Validation<'T, 'V>, f: 'T -> 'U, g: 'V -> 'W) : Validation<'U, 'W> = Validation.bimap f g x
 
     #if !FABLE_COMPILER || FABLE_COMPILER_3
 
     // as Traversable
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member inline Traverse (t: Validation<'err,'a>, f: 'a->'b) : 'c = Validation.traverse f t
+    static member inline Traverse (t: Validation<'Error, 'T>, f: 'T -> '``Functor<'U>``) : '``Functor<Validation<'Error, 'U>>`` = Validation.traverse f t
 
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member inline Sequence (t: Validation<'err,'a>) : 'c = Validation.sequence t
+    static member inline Sequence (t: Validation<'Error, '``Functor<'T>``>) : '``Functor<Validation<'Error, 'T>>`` = Validation.sequence t
 
     #endif
 

src/FSharpPlus/Extensions/List.fs

@@ -357,19 +357,14 @@ module List =
     /// <param name="i">The index of the item to remove </param>
     /// <param name="lst">The input list</param>
     /// 
-    /// <returns>For invalid indexes, the input list.  Otherwise, a new list with the item removed.</returns>
+    /// <returns>For invalid indexes, the input list. Otherwise, a new list with the item removed.</returns>
+    /// <remarks>Use List.removeAt from FSharp.Core if you want to throw exceptions when using invalid indexes.</remarks>
     let deleteAt i lst =
          if List.length lst > i then
              lst.[0..i-1] @ lst.[i+1..]
          else lst
 
-    /// <summary>Attempts to remove an item from a list.</summary>
-    /// <param name="i">The index of the item to remove </param>
-    /// <param name="lst">The input list</param>
-    ///
-    /// <returns>For invalid indexes, the input list.  Otherwise, a new list with the item removed.</returns>
-    /// <remarks>Use deletaAt instead or if you want to throw exceptions use the full path to removeAt in FSharp.Core until this function is removed from this library.</remarks>
-    [<Obsolete("This function was included in FSharp.Core but throwing")>]
+    [<Obsolete("This function was included in FSharp.Core but throwing. Use deletaAt instead or if you want to throw exceptions use the full path to removeAt in FSharp.Core until this function is removed from this library")>]
     let removeAt i lst = deleteAt i lst
 
     /// <summary>Updates the value of an item in a list</summary>
@@ -378,9 +373,8 @@ module List =
     /// <param name="lst">The input list</param>
     ///
     /// <returns>A new list with the updated element</returns>
-    /// <remarks>Use List.updateAt if you want to throw exceptions when using invalid indexes.</remarks>
+    /// <remarks>Use List.updateAt from FSharp.Core if you want to throw exceptions when using invalid indexes.</remarks>
     let setAt i x lst =
         if List.length lst > i && i >= 0 then
             lst.[0..i-1] @ x::lst.[i+1..]
         else lst
-

src/FSharpPlus/Extensions/Result.fs

@@ -61,6 +61,16 @@ module Result =
         | Error e, _, _
         | _, Error e, _
         | _, _, Error e -> Error e
+
+    /// <summary>Maps both Ok and Error of a Result.</summary>
+    /// <param name="errorMapper">Function to be applied to source, if it contains an Error value.</param>
+    /// <param name="okMapper">Function to be applied to source, if it contains an Ok value.</param>
+    /// <param name="source">The source value, containing an Ok or an Error.</param>
+    /// <returns>The result of applying the corresponding mapping function.</returns>
+    let bimap (errorMapper: 'TError -> 'UError) (okMapper: 'T -> 'U) source =
+        match source with
+        | Error e -> Error (errorMapper e)
+        | Ok a -> Ok (okMapper a)
 
     /// <summary>Flattens two nested Results.</summary>
     /// <param name="source">The nested Results.</param>

src/FSharpPlus/Lens.fs

@@ -126,10 +126,10 @@ module Lens =
     module List =      
         /// Given a specific key, produces a Lens from a List<value> to an Option<value>. When setting,
         /// a Some(value) will insert or replace the value into the list at the given index. Setting a value of
-        /// None will delete the value at the specified index.  Works well together with non.
-        let inline _item i f t = 
+        /// None will delete the value at the specified index. Works well together with non.
+        let inline _item i f t =
             Map.InvokeOnInstance
-                (function | None -> List.removeAt i t | Some x -> List.setAt i x t)
+                (function None -> List.deleteAt i t | Some x -> List.setAt i x t)
                 (f (List.tryItem i t))
 
     [<RequireQualifiedAccess>]

tests/FSharpPlus.Tests/ComputationExpressions.fs

@@ -76,6 +76,22 @@ module ComputationExpressions =
         testTryFinallyCaught ()
         ()
 
+        // specialized to Validation
+
+        let mk1 (s: string) = if true then  Success '1' else Failure [s]
+        let mk2 (s: string) = if false then Success 1 else Failure [s]
+        let mk3 (s: string) = if false then Success true else Failure [s]
+
+        let f x = applicative<Validation<_,_>> {
+            let! x = mk1 x
+            and! y = mk2 "2"
+            and! z = mk3 "3"
+            return (x, y, z) }
+        let _ = f "1"
+
+        ()
+
+
     [<Test>]
     let monadFx () =
         SideEffects.reset ()