remove unnecessary files

Author: dsyme

src/FSharp.Control.AsyncSeq/Async.fs

@@ -5,9 +5,9 @@
 namespace FSharp.Control
 
 open System
-open System.Threading
 open System.IO
-open FSharp.Control.Utils
+open System.Threading
+open System.Threading.Tasks
 
 // ----------------------------------------------------------------------------
 
@@ -24,6 +24,94 @@ and AsyncSeqInner<'T> =
     | Nil
     | Cons of 'T * AsyncSeq<'T>
 
+[<AutoOpen>]
+module internal Utils = 
+    module internal Choice =
+  
+      /// Maps over the left result type.
+      let mapl (f:'a -> 'b) = function
+        | Choice1Of2 a -> f a |> Choice1Of2
+        | Choice2Of2 e -> Choice2Of2 e
+
+      /// Maps over the right result type.
+      let mapr (f:'b -> 'c) = function
+        | Choice1Of2 a -> Choice1Of2 a
+        | Choice2Of2 e -> f e |> Choice2Of2
+
+    // ----------------------------------------------------------------------------
+
+    module internal Observable =
+
+        /// Union type that represents different messages that can be sent to the
+        /// IObserver interface. The IObserver type is equivalent to a type that has
+        /// just OnNext method that gets 'ObservableUpdate' as an argument.
+        type internal ObservableUpdate<'T> = 
+            | Next of 'T
+            | Error of exn
+            | Completed
+
+
+        /// Turns observable into an observable that only calls OnNext method of the
+        /// observer, but gives it a discriminated union that represents different
+        /// kinds of events (error, next, completed)
+        let asUpdates (input:IObservable<'T>) = 
+          { new IObservable<_> with
+              member x.Subscribe(observer) =
+                input.Subscribe
+                  ({ new IObserver<_> with
+                      member x.OnNext(v) = observer.OnNext(Next v)
+                      member x.OnCompleted() = observer.OnNext(Completed) 
+                      member x.OnError(e) = observer.OnNext(Error e) }) }
+
+    type Microsoft.FSharp.Control.Async with       
+      /// Starts the specified operation using a new CancellationToken and returns
+      /// IDisposable object that cancels the computation. This method can be used
+      /// when implementing the Subscribe method of IObservable interface.
+      static member StartDisposable(op:Async<unit>) =
+          let ct = new System.Threading.CancellationTokenSource()
+          Async.Start(op, ct.Token)
+          { new IDisposable with 
+              member x.Dispose() = ct.Cancel() }
+
+      /// Creates an async computations which runs the specified computations
+      /// in parallel and returns their results.
+      static member Parallel(a:Async<'a>, b:Async<'b>) : Async<'a * 'b> = async {
+        let! a = a |> Async.StartChild
+        let! b = b |> Async.StartChild
+        let! a = a
+        let! b = b
+        return a,b }
+
+
+      /// Creates an async computation which maps a function f over the 
+      /// value produced by the specified asynchronous computation.
+      static member map f a = async.Bind(a, f >> async.Return)
+
+      /// Creates an async computation which binds the result of the specified 
+      /// async computation to the specified function. The computation produced 
+      /// by the specified function is returned.
+      static member bind f a = async.Bind(a, f)
+
+      /// Creates a computation which produces a tuple consiting of the value produces by the first
+      /// argument computation to complete and a handle to the other computation. The second computation
+      /// to complete is memoized.
+      static member internal chooseBoth (a:Async<'a>) (b:Async<'a>) : Async<'a * Async<'a>> =
+        Async.FromContinuations <| fun (ok,err,cnc) ->
+          let state = ref 0            
+          let tcs = TaskCompletionSource<'a>()            
+          let inline ok a =
+            if (Interlocked.CompareExchange(state, 1, 0) = 0) then
+              ok (a, tcs.Task |> Async.AwaitTask)
+            else
+              tcs.SetResult a
+          let inline err (ex:exn) =
+            if (Interlocked.CompareExchange(state, 1, 0) = 0) then err ex
+            else tcs.SetException ex
+          let inline cnc ex =
+            if (Interlocked.CompareExchange(state, 1, 0) = 0) then cnc ex
+            else tcs.SetCanceled()
+          Async.StartWithContinuations(a, ok, err, cnc)
+          Async.StartWithContinuations(b, ok, err, cnc)
 
 /// Module with helper functions for working with asynchronous sequences
 module AsyncSeq = 
@@ -321,9 +409,9 @@ module AsyncSeq =
       let rec loop() = asyncSeq {
         let! msg = agent.PostAndAsyncReply(Get)
         match msg with
-        | ObservableUpdate.Error e -> raise e
-        | ObservableUpdate.Completed -> ()
-        | ObservableUpdate.Next v ->
+        | Observable.Error e -> raise e
+        | Observable.Completed -> ()
+        | Observable.Next v ->
             yield v
             yield! loop() }
       yield! loop() }

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -58,11 +58,8 @@
   -->
   <Import Project="..\..\.paket\paket.targets" />
   <ItemGroup>
-    <Compile Include="Utils.fs" />
     <Compile Include="AutoCancelAgent.fs" />
     <Compile Include="BlockingQueueAgent.fs" />
-    <Compile Include="Observable.fs" />
-    <Compile Include="Async.fs" />
     <Compile Include="AsyncSeq.fs" />
     <None Include="paket.references" />
     <None Include="paket.template" />

src/FSharp.Control.AsyncSeq/FSharp.Control.AsyncSeq.fsproj

@@ -4,6 +4,10 @@ open NUnit.Framework
 open FSharp.Control
 open System
 
+module AsyncOps = 
+    let unit = async.Return()
+    let never = Async.Sleep(-1)
+
 /// Determines equality of two async sequences by convering them to lists, ignoring side-effects.
 let EQ (a:AsyncSeq<'a>) (b:AsyncSeq<'a>) = 
   let exp = a |> AsyncSeq.toList |> Async.RunSynchronously