cleanup names

Author: dsyme

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -235,14 +235,14 @@ module AsyncSeq =
     //
     // because F# translates body as Bind(something, fun () -> Return())
     member x.Return _ = empty
-    member x.YieldFrom(s) = s
+    member x.YieldFrom(s:AsyncSeq<'T>) = s
     member x.Zero () = empty
     member x.Bind (inp:Async<'T>, body : 'T -> AsyncSeq<'U>) : AsyncSeq<'U> = 
       bindAsync body inp
     member x.Combine (seq1:AsyncSeq<'T>,seq2:AsyncSeq<'T>) = 
       append seq1 seq2
-    member x.While (gd, seq:AsyncSeq<'T>) = 
-      if gd() then x.Combine(seq,x.Delay(fun () -> x.While (gd, seq))) else x.Zero()
+    member x.While (guard, body:AsyncSeq<'T>) = 
+      if guard() then x.Combine(body,x.Delay(fun () -> x.While (guard, body))) else x.Zero()
     member x.Delay (f:unit -> AsyncSeq<'T>) = 
       delay f
 

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -61,7 +61,7 @@ module AsyncSeq =
         new : unit -> AsyncSeqBuilder
 
         /// Implements binding for the asyncSeq computation builder.
-        member Bind : inpredicate:Async<'T> * body:('T -> AsyncSeq<'U>) -> AsyncSeq<'U>
+        member Bind : source:Async<'T> * body:('T -> AsyncSeq<'U>) -> AsyncSeq<'U>
 
         /// Implements sequential composition for the asyncSeq computation builder.
         member Combine : seq1:AsyncSeq<'T> * seq2:AsyncSeq<'T> -> AsyncSeq<'T>
@@ -71,14 +71,14 @@ module AsyncSeq =
 
         /// For loop that iterates over a synchronous sequence (and generates
         /// all elements generated by the asynchronous body)
-        member For : seq:seq<'T> * action:('T -> AsyncSeq<'TResult>) -> AsyncSeq<'TResult>
+        member For : source:seq<'T> * action:('T -> AsyncSeq<'TResult>) -> AsyncSeq<'TResult>
 
         /// Implements "for" loops for the asyncSeq computation builder.
         ///
         /// Asynchronous for loop - for all elements from the input sequence,
         /// generate all elements produced by the body (asynchronously). See
         /// also the AsyncSeq.collect function.
-        member For : seq:AsyncSeq<'T> * action:('T -> AsyncSeq<'TResult>) -> AsyncSeq<'TResult>
+        member For : source:AsyncSeq<'T> * action:('T -> AsyncSeq<'TResult>) -> AsyncSeq<'TResult>
 
         /// Implements "return" for the asyncSeq computation builder.
         member Return : 'unit -> AsyncSeq<'T> 
@@ -93,13 +93,13 @@ module AsyncSeq =
         member Using : resource:'T * binder:('T -> AsyncSeq<'U>) -> AsyncSeq<'U> when 'T :> System.IDisposable
 
         /// Implements "while" for the asyncSeq computation builder.
-        member While : gd:(unit -> bool) * seq:AsyncSeq<'T> -> AsyncSeq<'T>
+        member While : guard:(unit -> bool) * body:AsyncSeq<'T> -> AsyncSeq<'T>
 
         /// Implements "yield" for the asyncSeq computation builder.
-        member Yield : v:'T -> AsyncSeq<'T>
+        member Yield : value:'T -> AsyncSeq<'T>
 
         /// Implements "yield!" for the asyncSeq computation builder.
-        member YieldFrom : source:'U -> 'U
+        member YieldFrom : source:AsyncSeq<'T> -> AsyncSeq<'T>
 
         /// Implements empty for the asyncSeq computation builder.
         member Zero : unit -> AsyncSeq<'T>
@@ -215,7 +215,7 @@ module AsyncSeq =
     /// to the observable, a new copy of asynchronous sequence is started and is 
     /// sequentially iterated over (at the maximal possible speed). Disposing of the 
     /// observer cancels the iteration over asynchronous sequence. 
-    val toObservable : aseq:AsyncSeq<'T> -> System.IObservable<'T>
+    val toObservable : source:AsyncSeq<'T> -> System.IObservable<'T>
 
     /// Converts asynchronous sequence to a synchronous blocking sequence.
     /// The elements of the asynchronous sequence are consumed lazily.
@@ -237,12 +237,12 @@ module AsyncSeq =
     /// Combines two asynchronous sequences using the specified function.
     /// The values from sequences are retrieved in parallel.
     /// The resulting sequence stops when either of the argument sequences stop.
-    val zipWithAsync : z:('T1 -> 'T2 -> Async<'U>) -> a:AsyncSeq<'T1> -> b:AsyncSeq<'T2> -> AsyncSeq<'U>
+    val zipWithAsync : mapping:('T1 -> 'T2 -> Async<'U>) -> source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> AsyncSeq<'U>
 
     /// Combines two asynchronous sequences using the specified function.
     /// The values from sequences are retrieved in parallel.
     /// The resulting sequence stops when either of the argument sequences stop.
-    val inline zipWith : z:('T1 -> 'T2 -> 'U) -> a:AsyncSeq<'T1> -> b:AsyncSeq<'T2> -> AsyncSeq<'U>
+    val inline zipWith : mapping:('T1 -> 'T2 -> 'U) -> source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> AsyncSeq<'U>
 
     /// Builds a new asynchronous sequence whose elements are generated by 
     /// applying the specified function to all elements of the input sequence.
@@ -323,26 +323,26 @@ module AsyncSeq =
 
     /// Interleaves two async sequences into a resulting sequence. The provided
     /// sequences are consumed in lock-step.
-    val interleave : firstSeq:AsyncSeq<'T1> -> secondSeq:AsyncSeq<'T2> -> AsyncSeq<Choice<'T1,'T2>>
+    val interleave : source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> AsyncSeq<Choice<'T1,'T2>>
 
     /// Buffer items from the async sequence into buffers of a specified size.
     /// The last buffer returned may be less than the specified buffer size.
     val bufferByCount : bufferSize:int -> source:AsyncSeq<'T> -> AsyncSeq<'T []>
 
     /// Merges two async sequences into an async sequence non-deterministically.
-    val mergeChoice: firstSeq:AsyncSeq<'T1> -> secondSeq:AsyncSeq<'T2> -> AsyncSeq<Choice<'T1,'T2>>
+    val mergeChoice: source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> AsyncSeq<Choice<'T1,'T2>>
 
     /// Merges two async sequences of the same typee into an async sequence non-deterministically.
-    val merge: firstSeq:AsyncSeq<'T> -> secondSeq:AsyncSeq<'T> -> AsyncSeq<'T>
+    val merge: source1:AsyncSeq<'T> -> source2:AsyncSeq<'T> -> AsyncSeq<'T>
 
     /// Merges all specified async sequences into an async sequence non-deterministically.
-    val mergeAll : ss:AsyncSeq<'T> list -> AsyncSeq<'T>
+    val mergeAll : sources:AsyncSeq<'T> list -> AsyncSeq<'T>
 
     /// Returns an async sequence which contains no contiguous duplicate elements based on the specified comparison function.
-    val distinctUntilChangedWithAsync : f:('T -> 'T -> Async<bool>) -> source:AsyncSeq<'T> -> AsyncSeq<'T>
+    val distinctUntilChangedWithAsync : mapping:('T -> 'T -> Async<bool>) -> source:AsyncSeq<'T> -> AsyncSeq<'T>
 
     /// Returns an async sequence which contains no contiguous duplicate elements based on the specified comparison function.
-    val distinctUntilChangedWith : f:('T -> 'T -> bool) -> source:AsyncSeq<'T> -> AsyncSeq<'T>
+    val distinctUntilChangedWith : mapping:('T -> 'T -> bool) -> source:AsyncSeq<'T> -> AsyncSeq<'T>
 
     /// Returns an async sequence which contains no contiguous duplicate elements.
     val distinctUntilChanged : source:AsyncSeq<'T> -> AsyncSeq<'T> when 'T : equality