Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: gdziadkiewicz

src/FSharpx.Collections/Deque.fs

@@ -244,11 +244,11 @@ module Deque =
     let inline toSeq(q: Deque<'T>) =
         q :> seq<'T>
 
-    ///O(n). Returns a list of the deque elements in FIFO order.
+    ///O(n). Returns a list of the deque elements in front-to-back (head-to-last) order.
     let toList(q: Deque<'T>) : 'T list =
         q.front @ List.rev q.rBack
 
-    ///O(n). Returns an array of the deque elements in FIFO order.
+    ///O(n). Returns an array of the deque elements in front-to-back (head-to-last) order.
     let toArray(q: Deque<'T>) : 'T[] =
         Array.ofSeq q
 

src/FSharpx.Collections/Deque.fsi

@@ -143,10 +143,10 @@ module Deque =
     ///O(n). Views the given deque as a sequence.
     val inline toSeq: Deque<'T> -> seq<'T>
 
-    ///O(n). Returns a list of the deque elements in FIFO order.
+    ///O(n). Returns a list of the deque elements in front-to-back (head-to-last) order.
     val toList: Deque<'T> -> 'T list
 
-    ///O(n). Returns an array of the deque elements in FIFO order.
+    ///O(n). Returns an array of the deque elements in front-to-back (head-to-last) order.
     val toArray: Deque<'T> -> 'T[]
 
     ///O(n). Returns a new deque whose elements are the results of applying the given function to each element.
@@ -159,11 +159,11 @@ module Deque =
     val iter: ('T -> unit) -> Deque<'T> -> unit
 
     ///O(n). Returns true if any element of the deque satisfies the given predicate.
-    ///Note: elements are not necessarily checked in FIFO order; the internal rear list is checked in reverse (LIFO) order.
+    ///Note: elements are not necessarily checked in front-to-back (enumeration) order; the internal rear list is checked in reverse order.
     val exists: ('T -> bool) -> Deque<'T> -> bool
 
     ///O(n). Returns true if all elements of the deque satisfy the given predicate.
-    ///Note: elements are not necessarily checked in FIFO order; the internal rear list is checked in reverse (LIFO) order.
+    ///Note: elements are not necessarily checked in front-to-back (enumeration) order; the internal rear list is checked in reverse order.
     val forall: ('T -> bool) -> Deque<'T> -> bool
 
     ///O(1) amortized, O(n), worst case. Returns option first element and tail.

tests/FSharpx.Collections.Tests/DequeTest.fs

@@ -1223,9 +1223,9 @@ module DequeTests =
                   (Prop.forAll(Arb.fromGen intGensStart2.[2])
                    <| fun (q, l) -> List.ofSeq q.TryInitial.Value = (List.rev l |> List.tail |> List.rev))
 
-              test "toList preserves FIFO order" {
+              test "toList preserves front-to-back order" {
                   let q = Deque.ofSeq [ 1; 2; 3; 4; 5 ]
-                  Expect.equal "toList" [ 1; 2; 3; 4; 5 ] (Deque.toList q)
+                  Expect.equal "toList preserves front-to-back order" [ 1; 2; 3; 4; 5 ] (Deque.toList q)
               }
 
               test "toList empty deque" { Expect.equal "toList empty" [] (Deque.toList Deque.empty) }

tests/FSharpx.Collections.Tests/QueueTest.fs

@@ -330,6 +330,12 @@ module QueueTests =
                   Expect.equal "toArray" [| 1; 2; 3 |] (Queue.toArray q)
               }
 
+              test "toArray preserves FIFO order across front/rBack boundary" {
+                  let q = Queue.ofSeq [ 1; 2; 3 ] |> Queue.conj 4 |> Queue.conj 5
+                  Expect.equal "toArray front/rBack" [| 1; 2; 3; 4; 5 |] (Queue.toArray q)
+              }
+
+              test "toArray empty queue" { Expect.equal "toArray empty" [||] (Queue.toArray Queue.empty) }
               test "map transforms elements" {
                   let q = Queue.ofSeq [ 1; 2; 3 ]
                   Expect.equal "map" [ 2; 4; 6 ] (Queue.map ((*) 2) q |> Queue.toList)