copied more async stuff from FSharpx

Author: forki

README.md

@@ -15,6 +15,7 @@ Please also join the [F# Open Source Group](http://fsharp.github.com)
 # Maintainer(s)
 
 - [@forki](https://github.com/forki)
+- [@tpetricek](https://github.com/tpetricek)
 - [@mausch](https://github.com/mausch)
 - [@panesofglass](https://github.com/panesofglass)
 

RELEASE_NOTES.md

@@ -1,2 +1,2 @@
-### 1.9.6 - 23.02.2015
+### 1.9.7 - 23.02.2015
 * Copied stuff from FSharpx

build.fsx

@@ -39,7 +39,7 @@ let summary = "Async extensions for F#"
 let description = "Async extensions for F#"
 
 // List of author names (for NuGet package)
-let authors = [ "Thomas Petricek, David Thomas, Steffen Forkmann" ]
+let authors = [ "Thomas Petricek"; "David Thomas"; "Ryan Riley"; "Steffen Forkmann" ]
 
 // Tags for your project (for NuGet package)
 let tags = "F#, async, fsharp"

paket.dependencies

@@ -7,4 +7,5 @@ nuget Nuget.CommandLine
 nuget FAKE
 nuget SourceLink.Fake
 
-github fsharp/FAKE modules/Octokit/Octokit.fsx
+github fsharp/FAKE modules/Octokit/Octokit.fsx
+github fsprojects/FSharpx.Collections src/FSharpx.Collections/CircularBuffer.fs

paket.lock

@@ -24,4 +24,7 @@ GITHUB
   remote: fsharp/FAKE
   specs:
     modules/Octokit/Octokit.fsx (575e7ab5050d2ddec80ba8d3a98cfb10ba327965)
-      Octokit
+      Octokit
+  remote: fsprojects/FSharpx.Collections
+  specs:
+    src/FSharpx.Collections/CircularBuffer.fs (e8fdc9c6d61618bdcc5c4f143ecbbfbe785b8ec4)

src/FSharpx.Async/Async.IO.fs

@@ -0,0 +1,124 @@
+// ----------------------------------------------------------------------------
+// F# async extensions (IO.fs)
+// (c) Tomas Petricek and Ryan Riley, 2011-2012, Available under Apache 2.0 license.
+// ----------------------------------------------------------------------------
+
+namespace FSharpx.IO
+open System.IO
+open FSharpx.Control
+// ----------------------------------------------------------------------------
+// Extensions that simplify working with Stream using async sequences
+
+[<AutoOpen>]
+module IOExtensions = 
+  type Stream with
+    /// Asynchronously reads the stream in chunks of a specified size
+    /// and returns the result as an asynchronous sequence.
+    member x.AsyncReadSeq(?bufferSize) = 
+      let bufferSize = defaultArg bufferSize 1024
+      let buffer = Array.zeroCreate bufferSize
+      let rec loop () = asyncSeq {
+        let! count = x.AsyncRead(buffer, 0, bufferSize)
+        if count > 0 then 
+          yield Array.sub buffer 0 count
+          yield! loop() }
+      loop ()
+
+    /// Asynchronously writes all data specified by the 
+    /// given asynchronous sequence to the stream.
+    member x.AsyncWriteSeq(input : AsyncSeq<byte[]>) = async {
+      for data in input do
+        do! x.AsyncWrite(data) }
+
+open System
+#if NET40
+open System.Diagnostics.Contracts
+#else
+open System.Diagnostics
+#endif
+
+// Loosely based on Stephen Toub's Stream Pipelines article in MSDN.
+// See http://msdn.microsoft.com/en-us/magazine/cc163290.aspx
+type CircularStream(maxLength) =
+    inherit Stream()
+
+    let queue = new CircularQueueAgent<byte>(maxLength)
+
+    override x.CanRead = true
+    override x.CanSeek = false
+    // We deviate from Toub's implementation in that we
+    // never prevent writes.
+    override x.CanWrite = true
+    
+    override x.Flush() = ()
+    override x.Length = raise <| new NotSupportedException()
+    override x.Position
+        with get() = raise <| new NotSupportedException()
+        and set(v) = raise <| new NotSupportedException()
+    override x.Seek(offset, origin) = raise <| new NotSupportedException()
+    override x.SetLength(value) = raise <| new NotSupportedException()
+
+    override x.Read(buffer, offset, count) =
+        #if NET40
+        Contract.Requires(buffer <> null, "buffer cannot be null")
+        Contract.Requires(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Contract.Requires(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #else
+        Debug.Assert(buffer <> null, "buffer cannot be null")
+        Debug.Assert(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Debug.Assert(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #endif
+
+        if count = 0 then 0 else
+        let chunk = queue.Dequeue(count)
+        Buffer.BlockCopy(chunk, 0, buffer, offset, chunk.Length)
+        chunk.Length
+
+    override x.Write(buffer, offset, count) =
+        #if NET40
+        Contract.Requires(buffer <> null, "buffer cannot be null")
+        Contract.Requires(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Contract.Requires(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #else
+        Debug.Assert(buffer <> null, "buffer cannot be null")
+        Debug.Assert(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Debug.Assert(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #endif
+
+        if count = 0 then () else
+        queue.Enqueue(buffer, offset, count)
+
+    member x.AsyncRead(buffer: byte[], offset, count, ?timeout) =
+        #if NET40
+        Contract.Requires(buffer <> null, "buffer cannot be null")
+        Contract.Requires(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Contract.Requires(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #else
+        Debug.Assert(buffer <> null, "buffer cannot be null")
+        Debug.Assert(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Debug.Assert(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #endif
+
+        if count = 0 then async.Return(0) else
+        async {
+            let! chunk = queue.AsyncDequeue(count, ?timeout = timeout)
+            Buffer.BlockCopy(chunk, 0, buffer, offset, chunk.Length)
+            return chunk.Length }
+
+    member x.AsyncWrite(buffer: byte[], offset, count, ?timeout) =
+        #if NET40
+        Contract.Requires(buffer <> null, "buffer cannot be null")
+        Contract.Requires(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Contract.Requires(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #else
+        Debug.Assert(buffer <> null, "buffer cannot be null")
+        Debug.Assert(offset >= 0 && offset < buffer.Length, "offset is out of range")
+        Debug.Assert(count >= 0 && offset + count <= buffer.Length, "count is out of range")
+        #endif
+
+        if count = 0 then async.Zero() else
+        async { do! queue.AsyncEnqueue(buffer, offset, count, ?timeout = timeout) }
+
+    override x.Close() =
+        base.Close()
+        // TODO: Close the queue agent.