Return array

Author: cjliberty

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1484,19 +1484,19 @@ module AsyncSeq =
           yield buffer.ToArray() }
 
   let toSortedSeq fn source =
-    toArrayAsync source |> Async.map (fun source' -> (fn source' :> seq<'T>)) |> Async.RunSynchronously
+    toArrayAsync source |> Async.map fn |> Async.RunSynchronously
 
-  let sort (source:AsyncSeq<'T>) : seq<'T> when 'T : comparison =
-    toSortedSeq Seq.sort source
+  let sort (source:AsyncSeq<'T>) : array<'T> when 'T : comparison =
+    toSortedSeq Array.sort source
 
-  let sortBy (projection:'T -> 'Key) (source:AsyncSeq<'T>) : seq<'T> when 'Key : comparison =
-    toSortedSeq (Seq.sortBy projection) source
+  let sortBy (projection:'T -> 'Key) (source:AsyncSeq<'T>) : array<'T> when 'Key : comparison =
+    toSortedSeq (Array.sortBy projection) source
 
-  let sortDescending (source:AsyncSeq<'T>) : seq<'T> when 'T : comparison =
-    toSortedSeq Seq.sortDescending source
+  let sortDescending (source:AsyncSeq<'T>) : array<'T> when 'T : comparison =
+    toSortedSeq Array.sortDescending source
 
-  let sortByDescending (projection:'T -> 'Key) (source:AsyncSeq<'T>) : seq<'T> when 'Key : comparison =
-    toSortedSeq (Seq.sortByDescending projection) source
+  let sortByDescending (projection:'T -> 'Key) (source:AsyncSeq<'T>) : array<'T> when 'Key : comparison =
+    toSortedSeq (Array.sortByDescending projection) source
 
   #if !FABLE_COMPILER
   let bufferByCountAndTime (bufferSize:int) (timeoutMs:int) (source:AsyncSeq<'T>) : AsyncSeq<'T[]> =

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -441,25 +441,25 @@ module AsyncSeq =
     /// This function returns a sequence that digests the whole initial sequence as soon as
     /// that sequence is iterated. As a result this function should not be used with
     /// large or infinite sequences.
-    val sort : source:AsyncSeq<'T> -> seq<'T> when 'T : comparison
+    val sort : source:AsyncSeq<'T> -> array<'T> when 'T : comparison
 
-    /// Applies a key-generating function to each element of an AsyncSeq and yield a sequence ordered by keys.
-    /// This function returns a sequence that digests the whole initial sequence as soon as
+    /// Applies a key-generating function to each element of an AsyncSeq and yield an array ordered by keys.
+    /// This function returns an array that digests the whole initial sequence as soon as
     /// that sequence is iterated. As a result this function should not be used with
     /// large or infinite sequences.
-    val sortBy : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> seq<'T> when 'Key : comparison
+    val sortBy : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> array<'T> when 'Key : comparison
 
-    /// Yields a sequence ordered descending by keys.
-    /// This function returns a sequence that digests the whole initial sequence as soon as
+    /// Yields an array ordered descending by keys.
+    /// This function returns an array that digests the whole initial sequence as soon as
     /// that sequence is iterated. As a result this function should not be used with
     /// large or infinite sequences.
-    val sortDescending : source:AsyncSeq<'T> -> seq<'T> when 'T : comparison
+    val sortDescending : source:AsyncSeq<'T> -> array<'T> when 'T : comparison
 
-    /// Applies a key-generating function to each element of an AsyncSeq and yield a sequence ordered descending by keys.
-    /// This function returns a sequence that digests the whole initial sequence as soon as
+    /// Applies a key-generating function to each element of an AsyncSeq and yield an array ordered descending by keys.
+    /// This function returns an array that digests the whole initial sequence as soon as
     /// that sequence is iterated. As a result this function should not be used with
     /// large or infinite sequences.
-    val sortByDescending : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> seq<'T> when 'Key : comparison
+    val sortByDescending : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> array<'T> when 'Key : comparison
 
     /// Interleaves two async sequences of the same type into a resulting sequence. The provided
     /// sequences are consumed in lock-step.

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

@@ -1736,30 +1736,30 @@ let ``Async.concat should work``() =
 [<Test>]
 let ``AsyncSeq.sort should work for``() =
   let input = [1; 3; 2; 5; 7; 4; 6] |> AsyncSeq.ofSeq
-  let expected = [1..7]
+  let expected = [|1..7|]
   let actual = input |> AsyncSeq.sort
   Assert.AreEqual(expected, actual)
 
 [<Test>]
 let ``AsyncSeq.sortDescending should work``() =
   let input = [1; 3; 2; Int32.MaxValue; 4; 6; Int32.MinValue; 5; 7; 0] |> AsyncSeq.ofSeq
-  let expected = seq { yield Int32.MaxValue; yield! seq{ 7..-1..0 }; yield Int32.MinValue }
+  let expected = seq { yield Int32.MaxValue; yield! seq{ 7..-1..0 }; yield Int32.MinValue } |> Array.ofSeq
   let actual = input |> AsyncSeq.sortDescending
   Assert.AreEqual(expected, actual)
 
 [<Test>]
 let ``AsyncSeq.sortBy should work``() =
   let fn x = Math.Abs(x-5)
   let input = [1; 2; 4; 5; 7] |> AsyncSeq.ofSeq
-  let expected = [5; 4; 7; 2; 1]
+  let expected = [|5; 4; 7; 2; 1|]
   let actual = input |> AsyncSeq.sortBy fn
   Assert.AreEqual(expected, actual)
 
 [<Test>]
 let ``AsyncSeq.sortByDescending should work``() =
   let fn x = Math.Abs(x-5)
   let input = [1; 2; 4; 5; 6; 7;] |> AsyncSeq.ofSeq
-  let expected = [1; 2; 7; 4; 6; 5;]
+  let expected = [|1; 2; 7; 4; 6; 5;|]
   let actual = input |> AsyncSeq.sortByDescending fn
   Assert.AreEqual(expected, actual)