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
@@ -256,17 +256,10 @@ type Gather =
         let cons_f x ys = Map.Invoke (cons: 'a -> seq<_> -> seq<_>) (f x) <.> ys
         Seq.foldBack cons_f t (Pure.Invoke Seq.empty)
 
-    
 
-    static member inline Gather (t: ^a, f, [<Optional>]_output: 'R, [<Optional>]_impl: Default1) : 'R =
-        #if TEST_TRACE
-        Traces.add "Gather ^a"
-        #endif
-        Gather.InvokeOnInstance f t
-    static member inline Gather (_: ^a when ^a : null and ^a :struct, _, _: 'R, _impl: Default1) = id
 
     #if !FABLE_COMPILER
-    static member Gather (t: 't seq, f: 't -> Async<'u>, [<Optional>]_output: Async<seq<'u>>, [<Optional>]_impl: Gather) : Async<seq<_>> =
+    static member Gather (t: 't seq, f: 't -> Async<'u>, [<Optional>]_output: Async<seq<'u>>, [<Optional>]_impl: Default2) : Async<seq<_>> =
         #if TEST_TRACE
         Traces.add "Gather 't seq, 't -> Async<'u>"
         #endif
@@ -277,6 +270,13 @@ type Gather =
                 while enum.MoveNext() do
                     yield Async.AsTask(f enum.Current, cancellationToken = ct).Result } }
     #endif
+    
+    static member inline Gather (t: ^a, f, [<Optional>]_output: 'R, [<Optional>]_impl: Default1) : 'R =
+        #if TEST_TRACE
+        Traces.add "Gather ^a"
+        #endif
+        Gather.InvokeOnInstance f t
+    static member inline Gather (_: ^a when ^a : null and ^a :struct, _, _: 'R, _impl: Default1) = id
 
 
     static member Gather (t: Id<'t>, f: 't -> option<'u>, [<Optional>]_output: option<Id<'u>>, [<Optional>]_impl: Gather) =
@@ -406,4 +406,4 @@ type Transpose with
         let inline call (a: 'a, b: 'b) = call_3 (a, b, Unchecked.defaultof<'R>) : 'R
         call (Unchecked.defaultof<Transpose>, t)
 
-#endif
+#endif

src/FSharpPlus/Data/NonEmptySeq.fs

@@ -95,19 +95,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