Add ignore to some common type extensions

src/FSharpPlus/Extensions/Observable.fs

@@ -6,6 +6,7 @@ open System
 open System.Threading
 open System.Threading.Tasks
 open System.Runtime.ExceptionServices
+open FSharpPlus.Internals.Errors
 open FSharpPlus.Data
 
 /// Additional operations on Observable<'T>
@@ -33,6 +34,14 @@ module Observable =
                     member _.OnError e = observer.OnNext (Error (ExceptionDispatchInfo.Capture e)) }}
 
 
+    /// Ignores the values resulting from each OnNext call.
+    /// Only the side-effects of the observable are preserved.
+    /// <param name="source">The source observable.</param>
+    /// <returns>An observable that ignores the values of the source observable.</returns>
+    let ignore (source: IObservable<'T>) : IObservable<unit> =
+        let source = nullArgCheck (nameof source) source
+
+        Observable.map ignore source
 
 
     let toAsyncSeq (source: System.IObservable<'T>) : SeqT<Async<bool>, 'T> = monad.plus {

src/FSharpPlus/Extensions/Option.fs

@@ -70,3 +70,11 @@ module Option =
         match pair with
         | (true,  x) -> Some x
         | (false, _) -> None
+
+    /// <summary>Ignores the value inside the option, if any.</summary>
+    /// <param name="source">The option value.</param>
+    /// <returns><c>Some ()</c> if the option is <c>Some</c>, <c>None</c> otherwise.</returns>
+    let ignore (source: option<'T>) =
+        match source with
+        | Some _ -> Some ()
+        | None   -> None

src/FSharpPlus/Extensions/Result.fs

@@ -176,3 +176,11 @@ module Result =
         | Error e, Ok _, Ok _ | Ok _, Error e, Ok _ | Ok _, Ok _, Error e -> Error e
         | Ok _, Error e1, Error e2 | Error e1, Ok _, Error e2 | Error e1, Error e2, Ok _ -> Error (combiner e1 e2)
         | Error e1, Error e2, Error e3 -> Error (combiner (combiner e1 e2) e3)
+
+    /// <summary>Ignores the value inside the result, if any.</summary>
+    /// <param name="source">The result value.</param>
+    /// <returns><c>Ok ()</c> if the result is <c>Ok</c>, <c>Error e</c> otherwise.</returns>
+    let ignore (source: Result<'T, 'Error>) =
+        match source with
+        | Ok _ -> Ok ()
+        | Error e -> Error e

src/FSharpPlus/Extensions/Seq.fs

@@ -361,3 +361,12 @@ module Seq =
         |> nullArgCheck (nameof source)
         |> Seq.indexed
         |> Seq.choose (fun (a, b) -> mapping a b)
+
+    /// <summary>Ignores the values resulting from each iteration inside the sequence.</summary>
+    /// <param name="source">The sequence value.</param>
+    /// <returns> A sequence of unit values.</returns>
+    /// <remarks>It can be used to convert a non-generic IEnumerable to a unit seq.</remarks>
+    let ignore (source: Collections.IEnumerable) =
+        let source = nullArgCheck (nameof source) source
+
+        seq { for _ in source do yield () }

src/FSharpPlus/Extensions/ValueOption.fs

@@ -82,3 +82,11 @@ module ValueOption =
         match source with
         | Some x -> ValueSome x
         | None   -> ValueNone
+
+    /// <summary>Ignores the value inside the option, if any.</summary>
+    /// <param name="source">The option value.</param>
+    /// <returns><c>ValueSome ()</c> if the option is <c>ValueSome</c>, <c>ValueNone</c> otherwise.</returns>
+    let ignore (source: ValueOption<'T>) =
+        match source with
+        | ValueSome _ -> ValueSome ()
+        | ValueNone   -> ValueNone