[Repo Assist] Add AsyncSeq.sumBy, sumByAsync, average, averageBy, averageByAsync (#245)

* Add AsyncSeq.sumBy, sumByAsync, average, averageBy, averageByAsync

These mirror the corresponding Seq module functions and complement the
existing AsyncSeq.sum combinator:

- sumBy / sumByAsync: map-then-sum using sync/async projection
- average: compute mean of a numeric async sequence
- averageBy / averageByAsync: map-then-average using sync/async projection

All raise InvalidArgumentException on empty sequences (average variants).
6 new tests added; all 200 tests pass.

Co-authored-by: Copilot <[email protected]>

* ci: trigger CI checks

---------

Co-authored-by: Repo Assist <[email protected]>
Co-authored-by: Copilot <[email protected]>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: 3 people

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1151,6 +1151,33 @@ module AsyncSeq =
   let inline sum (source : AsyncSeq<'T>) : Async<'T> =
     (LanguagePrimitives.GenericZero, source) ||> fold (+)
 
+  let inline sumBy (projection : 'T -> ^U) (source : AsyncSeq<'T>) : Async<^U> =
+    fold (fun s x -> s + projection x) LanguagePrimitives.GenericZero source
+
+  let inline sumByAsync (projection : 'T -> Async<^U>) (source : AsyncSeq<'T>) : Async<^U> =
+    foldAsync (fun s x -> async { let! v = projection x in return s + v }) LanguagePrimitives.GenericZero source
+
+  let inline average (source : AsyncSeq<^T>) : Async<^T> =
+    async {
+      let! sum, count = fold (fun (s, n) x -> (s + x, n + 1)) (LanguagePrimitives.GenericZero, 0) source
+      if count = 0 then invalidArg "source" "The input sequence was empty."
+      return LanguagePrimitives.DivideByInt sum count
+    }
+
+  let inline averageBy (projection : 'T -> ^U) (source : AsyncSeq<'T>) : Async<^U> =
+    async {
+      let! sum, count = fold (fun (s, n) x -> (s + projection x, n + 1)) (LanguagePrimitives.GenericZero, 0) source
+      if count = 0 then invalidArg "source" "The input sequence was empty."
+      return LanguagePrimitives.DivideByInt sum count
+    }
+
+  let inline averageByAsync (projection : 'T -> Async<^U>) (source : AsyncSeq<'T>) : Async<^U> =
+    async {
+      let! sum, count = foldAsync (fun (s, n) x -> async { let! v = projection x in return (s + v, n + 1) }) (LanguagePrimitives.GenericZero, 0) source
+      if count = 0 then invalidArg "source" "The input sequence was empty."
+      return LanguagePrimitives.DivideByInt sum count
+    }
+
   let scan f (state:'State) (source : AsyncSeq<'T>) =
     scanAsync (fun st v -> f st v |> async.Return) state source
 

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -211,6 +211,37 @@ module AsyncSeq =
                                 when ^T : (static member ( + ) : ^T * ^T -> ^T)
                                 and  ^T : (static member Zero : ^T)
 
+    /// Asynchronously sum the mapped elements of an asynchronous sequence using a synchronous projection.
+    val inline sumBy : projection:('T -> ^U) -> source:AsyncSeq<'T> -> Async< ^U>
+                                when ^U : (static member ( + ) : ^U * ^U -> ^U)
+                                and  ^U : (static member Zero : ^U)
+
+    /// Asynchronously sum the mapped elements of an asynchronous sequence using an asynchronous projection.
+    val inline sumByAsync : projection:('T -> Async< ^U>) -> source:AsyncSeq<'T> -> Async< ^U>
+                                when ^U : (static member ( + ) : ^U * ^U -> ^U)
+                                and  ^U : (static member Zero : ^U)
+
+    /// Asynchronously compute the average of the elements of the input asynchronous sequence.
+    /// Raises InvalidArgumentException if the sequence is empty.
+    val inline average : source:AsyncSeq< ^T> -> Async< ^T>
+                                when ^T : (static member ( + ) : ^T * ^T -> ^T)
+                                and  ^T : (static member DivideByInt : ^T * int -> ^T)
+                                and  ^T : (static member Zero : ^T)
+
+    /// Asynchronously compute the average of the mapped elements of an asynchronous sequence using a synchronous projection.
+    /// Raises InvalidArgumentException if the sequence is empty.
+    val inline averageBy : projection:('T -> ^U) -> source:AsyncSeq<'T> -> Async< ^U>
+                                when ^U : (static member ( + ) : ^U * ^U -> ^U)
+                                and  ^U : (static member DivideByInt : ^U * int -> ^U)
+                                and  ^U : (static member Zero : ^U)
+
+    /// Asynchronously compute the average of the mapped elements of an asynchronous sequence using an asynchronous projection.
+    /// Raises InvalidArgumentException if the sequence is empty.
+    val inline averageByAsync : projection:('T -> Async< ^U>) -> source:AsyncSeq<'T> -> Async< ^U>
+                                when ^U : (static member ( + ) : ^U * ^U -> ^U)
+                                and  ^U : (static member DivideByInt : ^U * int -> ^U)
+                                and  ^U : (static member Zero : ^U)
+
     /// Asynchronously determine if the sequence contains the given value
     val contains : value:'T -> source:AsyncSeq<'T> -> Async<bool> when 'T : equality
 

tests/FSharp.Control.AsyncSeq.Tests/AsyncSeqTests.fs

@@ -211,6 +211,52 @@ let ``AsyncSeq.sum works``() =
       let expected = ls |> List.sum
       Assert.True((expected = actual))
 
+[<Test>]
+let ``AsyncSeq.sumBy works``() =
+  for i in 0 .. 10 do
+      let ls = [ 1 .. i ]
+      let actual = AsyncSeq.ofSeq ls |> AsyncSeq.sumBy float |> Async.RunSynchronously
+      let expected = ls |> List.sumBy float
+      Assert.AreEqual(expected, actual)
+
+[<Test>]
+let ``AsyncSeq.sumByAsync works``() =
+  for i in 0 .. 10 do
+      let ls = [ 1 .. i ]
+      let actual = AsyncSeq.ofSeq ls |> AsyncSeq.sumByAsync (float >> async.Return) |> Async.RunSynchronously
+      let expected = ls |> List.sumBy float
+      Assert.AreEqual(expected, actual)
+
+[<Test>]
+let ``AsyncSeq.average works``() =
+  for i in 1 .. 10 do
+      let ls = [ 1.0 .. float i ]
+      let actual = AsyncSeq.ofSeq ls |> AsyncSeq.average |> Async.RunSynchronously
+      let expected = ls |> List.average
+      Assert.AreEqual(expected, actual)
+
+[<Test>]
+let ``AsyncSeq.average raises on empty sequence``() =
+  Assert.Throws<System.ArgumentException>(fun () ->
+      AsyncSeq.empty<float> |> AsyncSeq.average |> Async.RunSynchronously |> ignore
+  ) |> ignore
+
+[<Test>]
+let ``AsyncSeq.averageBy works``() =
+  for i in 1 .. 10 do
+      let ls = [ 1 .. i ]
+      let actual = AsyncSeq.ofSeq ls |> AsyncSeq.averageBy float |> Async.RunSynchronously
+      let expected = ls |> List.averageBy float
+      Assert.AreEqual(expected, actual)
+
+[<Test>]
+let ``AsyncSeq.averageByAsync works``() =
+  for i in 1 .. 10 do
+      let ls = [ 1 .. i ]
+      let actual = AsyncSeq.ofSeq ls |> AsyncSeq.averageByAsync (float >> async.Return) |> Async.RunSynchronously
+      let expected = ls |> List.averageBy float
+      Assert.AreEqual(expected, actual)
+
 
 [<Test>]
 let ``AsyncSeq.length works``() =