Add AsyncSeq.mapAsyncUnorderedParallelThrottled

Adds a new function that applies an async mapping in parallel (unordered
results) while limiting concurrency to a specified number of tasks.

Combines the patterns from mapAsyncUnorderedParallel (unordered emission)
and iterAsyncParallelThrottled (SemaphoreSlim-based throttling).

Closes #31

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

Author: 2 people

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -925,6 +925,34 @@ module AsyncSeq =
         | Choice1Of2 value -> return value
         | Choice2Of2 ex -> return raise ex })
   }
+
+  let mapAsyncUnorderedParallelThrottled (parallelism:int) (f:'a -> Async<'b>) (s:AsyncSeq<'a>) : AsyncSeq<'b> = asyncSeq {
+    use mb = MailboxProcessor.Start (fun _ -> async.Return())
+    use sm = new SemaphoreSlim(parallelism)
+    let! err =
+      s
+      |> iterAsync (fun a -> async {
+        do! sm.WaitAsync () |> Async.awaitTaskUnitCancellationAsError
+        let! b = Async.StartChild (async {
+          try
+            let! result = f a
+            sm.Release() |> ignore
+            return Choice1Of2 result
+          with ex ->
+            sm.Release() |> ignore
+            return Choice2Of2 ex
+        })
+        mb.Post (Some b) })
+      |> Async.map (fun _ -> mb.Post None)
+      |> Async.StartChildAsTask
+    yield!
+      replicateUntilNoneAsync (Task.chooseTask (err |> Task.taskFault) (async.Delay mb.Receive))
+      |> mapAsync (fun childAsync -> async {
+        let! result = childAsync
+        match result with
+        | Choice1Of2 value -> return value
+        | Choice2Of2 ex -> return raise ex })
+  }
   #endif
 
   let chooseAsync f (source:AsyncSeq<'T>) =

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -543,6 +543,14 @@ module AsyncSeq =
     /// Parallelism is bound by the ThreadPool.
     val mapAsyncUnorderedParallel : mapping:('T -> Async<'U>) -> s:AsyncSeq<'T> -> AsyncSeq<'U>
 
+    /// Builds a new asynchronous sequence whose elements are generated by
+    /// applying the specified function to all elements of the input sequence,
+    /// with at most <c>parallelism</c> mapping operations running concurrently.
+    ///
+    /// The function is applied to elements in parallel (throttled), and results are emitted
+    /// in the order they complete (unordered), without preserving the original order.
+    val mapAsyncUnorderedParallelThrottled : parallelism:int -> mapping:('T -> Async<'U>) -> s:AsyncSeq<'T> -> AsyncSeq<'U>
+
     /// Applies a key-generating function to each element and returns an async sequence containing unique keys
     /// and async sequences containing elements corresponding to the key.
     ///