Changed sort funcs to return seq

Author: cjliberty

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1483,32 +1483,20 @@ module AsyncSeq =
       if (buffer.Count > 0) then
           yield buffer.ToArray() }
 
-  let private getEnumerator fn source =
-    toArrayAsync source |> Async.map (fun source' -> (fn source' :> seq<'T>).GetEnumerator())
+  let toSortedSeq fn source =
+    toArrayAsync source |> Async.map (fun source' -> (fn source' :> seq<'T>)) |> Async.RunSynchronously
 
-  let sort (source:AsyncSeq<'T>) : AsyncSeq<'T> when 'T : comparison =  asyncSeq {
-    use! ie = getEnumerator Seq.sort source
-    while ie.MoveNext() do
-      yield ie.Current
-  }
+  let sort (source:AsyncSeq<'T>) : seq<'T> when 'T : comparison =
+    toSortedSeq Seq.sort source
 
-  let sortBy (projection:'T -> 'Key) (source:AsyncSeq<'T>) : AsyncSeq<'T> when 'Key : comparison =  asyncSeq {
-    use! ie = getEnumerator (Seq.sortBy projection) source
-    while ie.MoveNext() do
-      yield ie.Current
-  }
+  let sortBy (projection:'T -> 'Key) (source:AsyncSeq<'T>) : seq<'T> when 'Key : comparison =
+    toSortedSeq (Seq.sortBy projection) source
 
-  let sortDescending (source:AsyncSeq<'T>) : AsyncSeq<'T> when 'T : comparison =  asyncSeq {
-    use! ie = getEnumerator Seq.sortDescending source
-    while ie.MoveNext() do
-      yield ie.Current
-  }
+  let sortDescending (source:AsyncSeq<'T>) : seq<'T> when 'T : comparison =
+    toSortedSeq Seq.sortDescending source
 
-  let sortByDescending (projection:'T -> 'Key) (source:AsyncSeq<'T>) : AsyncSeq<'T> when 'Key : comparison =  asyncSeq {
-    use! ie = getEnumerator (Seq.sortByDescending projection) source
-    while ie.MoveNext() do
-      yield ie.Current
-  }
+  let sortByDescending (projection:'T -> 'Key) (source:AsyncSeq<'T>) : seq<'T> when 'Key : comparison =
+    toSortedSeq (Seq.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> -> AsyncSeq<'T> when 'T : comparison
+    val sort : source:AsyncSeq<'T> -> seq<'T> when 'T : comparison
 
     /// Applies a key-generating function to each element of an AsyncSeq and yield an AsyncSeq ordered by keys.
     /// 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 sortBy : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> AsyncSeq<'T> when 'Key : comparison
+    val sortBy : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> seq<'T> when 'Key : comparison
 
     /// Yields a AsyncSeq ordered descending by keys.
     /// 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 sortDescending : source:AsyncSeq<'T> -> AsyncSeq<'T> when 'T : comparison
+    val sortDescending : source:AsyncSeq<'T> -> seq<'T> when 'T : comparison
 
     /// Applies a key-generating function to each element of an AsyncSeq and yield an AsyncSeq ordered descending by keys.
     /// 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 sortByDescending : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> AsyncSeq<'T> when 'Key : comparison
+    val sortByDescending : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> seq<'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] |> AsyncSeq.ofSeq
+  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 } |> AsyncSeq.ofSeq
+  let expected = seq { yield Int32.MaxValue; yield! seq{ 7..-1..0 }; yield Int32.MinValue }
   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] |> AsyncSeq.ofSeq
+  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;] |> AsyncSeq.ofSeq
+  let expected = [1; 2; 7; 4; 6; 5;]
   let actual = input |> AsyncSeq.sortByDescending fn
   Assert.AreEqual(expected, actual)