Fix traversals

Author: gusty

src/FSharpPlus/Control/Traversable.fs

@@ -32,52 +32,52 @@ type Traverse =
     inherit Default1
     static member inline InvokeOnInstance f (t: ^a) = (^a : (static member Traverse : _ * _ -> 'R) t, f)
 
-    static member inline Traverse (t: '``Traversable<'T>``, f: 'T -> '``Functor<'U>``, [<Optional>]_output: '``Functor<'Traversable<'U>>``, [<Optional>]_impl: Default4) =
+    static member inline Traverse (t: '``Traversable<'T>``, f: 'T -> '``Functor<'U>``, [<Optional>]_output: '``Functor<'Traversable<'U>>``, [<Optional>]_impl: Default5) =
         #if TEST_TRACE
         Traces.add "Traverse 'Traversable, 'T -> Functor<'U>"
         #endif
         let mapped = Map.Invoke f t : '``Traversable<'Functor<'U>>``
         (^``Traversable<'T>`` : (static member Sequence : _ -> _) mapped) : '``Functor<'Traversable<'U>>``
 
-    static member inline Traverse (t: Id<_>, f, [<Optional>]_output: 'R, [<Optional>]_impl: Default3) =
+    static member inline Traverse (t: Id<_>, f, [<Optional>]_output: 'R, [<Optional>]_impl: Default4) =
         #if TEST_TRACE
         Traces.add "Traverse Id"
         #endif
         Map.Invoke Id.create (f (Id.run t))
 
-    static member inline Traverse (t: _ seq, f, [<Optional>]_output: 'R, [<Optional>]_impl: Default3) =
+    static member inline Traverse (t: _ seq, f, [<Optional>]_output: 'R, [<Optional>]_impl: Default4) =
         #if TEST_TRACE
         Traces.add "Traverse seq"
         #endif
         let cons_f x ys = Map.Invoke (Seq.cons: 'a -> seq<_> -> seq<_>) (f x) <*> ys
         Seq.foldBack cons_f t (result Seq.empty)
 
-    static member inline Traverse (t: seq<'T>, f: 'T -> '``Functor<'U>``, [<Optional>]_output: '``Functor<seq<'U>>``, [<Optional>]_impl: Default2) =
+    static member inline Traverse (t: seq<'T>, f: 'T -> '``Functor<'U>``, [<Optional>]_output: '``Functor<seq<'U>>``, [<Optional>]_impl: Default3) =
         #if TEST_TRACE
         Traces.add "Traverse seq, 'T -> Functor<'U>"
         #endif
         let mapped = Seq.map f t
         Sequence.ForInfiniteSequences (mapped, IsLeftZero.Invoke, List.toSeq, Return.Invoke) : '``Functor<seq<'U>>``
 
+    #if !FABLE_COMPILER
+    static member Traverse (t: 't seq, f: 't -> Async<'u>, [<Optional>]_output: Async<seq<'u>>, [<Optional>]_impl: Default2) : Async<seq<_>> =
+        #if TEST_TRACE
+        Traces.add "Traverse 't seq, 't -> Async<'u>"
+        #endif
+        async {
+            let! ct = Async.CancellationToken
+            return seq {
+                use enum = t.GetEnumerator ()
+                while enum.MoveNext() do
+                    yield Async.AsTask(f enum.Current, cancellationToken = ct).Result }}
+    #endif
+
     static member inline Traverse (t: ^a, f, [<Optional>]_output: 'R, [<Optional>]_impl: Default1) : 'R =
         #if TEST_TRACE
         Traces.add "Traverse ^a"
         #endif
         Traverse.InvokeOnInstance f t
     static member inline Traverse (_: ^a when ^a : null and ^a :struct, _, _: 'R, _impl: Default1) = id
-
-    #if !FABLE_COMPILER
-    static member Traverse (t: 't seq, f: 't -> Async<'u>, [<Optional>]_output: Async<seq<'u>>, [<Optional>]_impl: Traverse) : Async<seq<_>> = async {
-        #if TEST_TRACE
-        Traces.add "Traverse 't seq, 't -> Async<'u>"
-        #endif
-        
-        let! ct = Async.CancellationToken
-        return seq {
-            use enum = t.GetEnumerator ()
-            while enum.MoveNext() do
-                yield Async.AsTask(f enum.Current, cancellationToken = ct).Result }}
-    #endif
 
     static member Traverse (t: Id<'t>, f: 't -> option<'u>, [<Optional>]_output: option<Id<'u>>, [<Optional>]_impl: Traverse) =
         #if TEST_TRACE

src/FSharpPlus/Data/NonEmptySeq.fs

@@ -91,19 +91,12 @@ type NonEmptySeq<'t> =
 
     #if !FABLE_COMPILER
 
-    static member inline Traverse (t: _ seq, f) =
-        #if TEST_TRACE
-        Traces.add "Traverse NonEmptySeq: Seq, 'T -> Functor<'U>"
-        #endif
-        let cons_f x ys = Map.Invoke (Seq.cons: 'a -> seq<_> -> seq<_>) (f x) <*> ys
-        Map.Invoke NonEmptySeq<_>.unsafeOfSeq (Seq.foldBack cons_f t (result Seq.empty))
-
-    static member inline Traverse (t: NonEmptySeq<'T>, f: 'T -> '``Functor<'U>``) =
+    static member inline Traverse (t: NonEmptySeq<'T>, f: 'T -> '``Functor<'U>``, [<Optional>]_output: '``Functor<NonEmptySeq<'U>>``, [<Optional>]_impl: Default2) : '``Functor<NonEmptySeq<'U>>`` =
         #if TEST_TRACE
         Traces.add "Traverse NonEmptySeq: NonEmptySeq, 'T -> Functor<'U>"
         #endif
         let mapped = NonEmptySeq<_>.map f t
-        Sequence.ForInfiniteSequences (mapped, IsLeftZero.Invoke, NonEmptySeq<_>.ofList, Return.Invoke) : '``Functor<NonEmptySeq<'U>>``
+        Sequence.ForInfiniteSequences (mapped, IsLeftZero.Invoke, NonEmptySeq<_>.ofList, Return.Invoke)
 
     static member Traverse (t: 'T NonEmptySeq, f: 'T -> Async<'U>) : Async<NonEmptySeq<_>> =
         #if TEST_TRACE

tests/FSharpPlus.Tests/Traversals.fs

@@ -291,7 +291,7 @@ module Traversable =
         Assert.AreEqual(None, r3)
         Assert.IsInstanceOf<Option<NonEmptySeq<int> option>> (Some r3)
         #if TEST_TRACE
-        CollectionAssert.AreEqual (["Traverse ^a"; "Traverse NonEmptySeq: NonEmptySeq, 'T -> Functor<'U>"], Traces.get())
+        CollectionAssert.AreEqual (["Traverse NonEmptySeq: NonEmptySeq, 'T -> Functor<'U>"], Traces.get())
         #endif
 
         #if TEST_TRACE