Remove IFDEFs

Author: forki

FSharpx.Async.sln

@@ -1,13 +1,13 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".paket", ".paket", "{63297B98-5CED-492C-A5B7-A5B4F73CF142}"
- ProjectSection(SolutionItems) = preProject
+	ProjectSection(SolutionItems) = preProject
 		paket.dependencies = paket.dependencies
 		paket.lock = paket.lock
 	EndProjectSection
 EndProject
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{A6A6AF7D-D6E3-442D-9B1E-58CC91879BE1}"
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FSharpx.Async", "src\FSharpx.Async\FSharpx.Async.fsproj", "{2D4F3D0E-0E18-48D7-9C27-98864039393D}"
@@ -29,7 +29,6 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "content", "content", "{8E6D5255-776D-4B61-85F9-73C37AA1FB9A}"
 	ProjectSection(SolutionItems) = preProject
 		docs\content\index.fsx = docs\content\index.fsx
-		docs\content\tutorial.fsx = docs\content\tutorial.fsx
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{ED8079DD-2B06-4030-9F0F-DC548F98E1C4}"

src/FSharpx.Async/Async.IO.fs

@@ -31,11 +31,8 @@ module IOExtensions =
         do! x.AsyncWrite(data) }
 
 open System
-#if NET40
-open System.Diagnostics.Contracts
-#else
 open System.Diagnostics
-#endif
+open System.Diagnostics.Contracts
 
 // Loosely based on Stephen Toub's Stream Pipelines article in MSDN.
 // See http://msdn.microsoft.com/en-us/magazine/cc163290.aspx
@@ -59,45 +56,27 @@ type CircularStream(maxLength) =
     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 {
@@ -106,19 +85,13 @@ type CircularStream(maxLength) =
             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.
+        // TODO: Close the queue agent.

src/FSharpx.Async/Async.fs

@@ -34,33 +34,4 @@ module AsyncExtensions =
           let ct = new System.Threading.CancellationTokenSource()
           Async.Start(op, ct.Token)
           { new IDisposable with 
-              member x.Dispose() = ct.Cancel() }
-
-#if NET40
-
-      /// Starts a non-generic Task with the cancellationToken and returns an
-      /// Async<unit> containing the result.
-      static member AwaitTask(task:Tasks.Task, ?cancellationToken) =
-          let cancel = defaultArg cancellationToken Async.DefaultCancellationToken
-          Async.AwaitTask <| task.ContinueWith<unit>((fun t -> ()), cancel)
-
-      /// Starts a Task<'a> with the timeout and cancellationToken and
-      /// returns a Async<a' option> containing the result.  If the Task does
-      /// not complete in the timeout interval, or is faulted None is returned.
-      static member TryAwaitTask(task:Tasks.Task<_>, ?timeout, ?cancellationToken) =
-          let timeout = defaultArg timeout Timeout.Infinite
-          let cancel = defaultArg cancellationToken Async.DefaultCancellationToken
-          async {
-              return
-                if task.Wait(timeout, cancel) && not task.IsCanceled && not task.IsFaulted
-                then Some task.Result
-                else None }
-
-    /// Implements an extension method that overloads the standard
-    /// 'Bind' of the 'async' builder. The new overload awaits on 
-    /// a standard .NET task
-    type Microsoft.FSharp.Control.AsyncBuilder with
-        member x.Bind(t:Tasks.Task<'T>, f:'T -> Async<'R>) : Async<'R> = async.Bind(Async.AwaitTask t, f)
-        member x.Bind(t:Tasks.Task, f:unit -> Async<'R>)   : Async<'R> = async.Bind(Async.AwaitTask t, f)
-
-#endif
+              member x.Dispose() = ct.Cancel() }

src/FSharpx.Async/AsyncOperations.fs

@@ -51,15 +51,11 @@ namespace FSharpx.Control
             |   [] -> ()
             |   [cont] when reuseThread -> cont res
             |   otherwise ->
-#if FX_NO_SYNC_CONTEXT
-                    let postOrQueue cont = ThreadPool.QueueUserWorkItem(fun _ -> cont res) |> ignore
-#else
                     let synchContext = System.Threading.SynchronizationContext.Current
                     let postOrQueue =
                         match synchContext with
                         |   null -> fun cont -> ThreadPool.QueueUserWorkItem(fun _ -> cont res) |> ignore
-                        |   sc -> fun cont -> sc.Post((fun _ -> cont res), state=null)
-#endif                        
+                        |   sc -> fun cont -> sc.Post((fun _ -> cont res), state=null)                 
                     grabbedConts |> List.iter postOrQueue
 
         /// Get the reified result 
@@ -108,39 +104,20 @@ namespace FSharpx.Control
             static member AsyncAppendText(path) = UnblockViaNewThread (fun () -> System.IO.File.AppendText(path))
             static member AsyncOpenRead(path)   = UnblockViaNewThread (fun () -> System.IO.File.OpenRead(path))
             static member AsyncOpenWrite(path)  = UnblockViaNewThread (fun () -> System.IO.File.OpenWrite(path))
-#if FX_NO_FILE_OPTIONS
-            static member AsyncOpen(path,mode,?access,?share,?bufferSize) =
-#else
             static member AsyncOpen(path,mode,?access,?share,?bufferSize,?options) =
-#endif
                 let access = match access with Some v -> v | None -> System.IO.FileAccess.ReadWrite
                 let share = match share with Some v -> v | None -> System.IO.FileShare.None
-#if FX_NO_FILE_OPTIONS
-#else
                 let options = match options with Some v -> v | None -> System.IO.FileOptions.None
-#endif
                 let bufferSize = match bufferSize with Some v -> v | None -> 0x1000
                 UnblockViaNewThread (fun () -> 
-#if FX_NO_FILE_OPTIONS
-                    new System.IO.FileStream(path,mode,access,share,bufferSize))
-#else
                     new System.IO.FileStream(path,mode,access,share,bufferSize, options))
-#endif
 
             static member OpenTextAsync(path)   = System.IO.File.AsyncOpenText(path)
             static member AppendTextAsync(path) = System.IO.File.AsyncAppendText(path)
             static member OpenReadAsync(path)   = System.IO.File.AsyncOpenRead(path)
             static member OpenWriteAsync(path)  = System.IO.File.AsyncOpenWrite(path)
-#if FX_NO_FILE_OPTIONS
-            static member OpenAsync(path,mode,?access,?share,?bufferSize) = 
-                System.IO.File.AsyncOpen(path, mode, ?access=access, ?share=share,?bufferSize=bufferSize)
-#else
             static member OpenAsync(path,mode,?access,?share,?bufferSize,?options) = 
                 System.IO.File.AsyncOpen(path, mode, ?access=access, ?share=share,?bufferSize=bufferSize,?options=options)
-#endif
-
-#if FX_NO_FILE_OPTIONS
-#else
 
             // Aims to take advantage of IO completion ports using FileStream.AsyncWrite and FileOptions.Asynchronous, so no FX_NO_FILE_OPTIONS version
             static member AsyncWriteAllBytes(path, bytes) =
@@ -196,12 +173,6 @@ namespace FSharpx.Control
 
 
 
-#endif
-
-
-
-
-
 
 
     [<AutoOpen>]
@@ -211,8 +182,6 @@ namespace FSharpx.Control
             member s.AsyncReadToEnd () = FileExtensions.UnblockViaNewThread (fun () -> s.ReadToEnd())
             member s.ReadToEndAsync () = s.AsyncReadToEnd ()
 
-#if FX_NO_WEB_REQUESTS
-#else
     [<AutoOpen>]
     module WebRequestExtensions =
         open System
@@ -224,10 +193,7 @@ namespace FSharpx.Control
         type System.Net.WebRequest with
             member req.AsyncGetResponse() = callFSharpCoreAsyncGetResponse req // this calls the FSharp.Core method
             member req.GetResponseAsync() = callFSharpCoreAsyncGetResponse req // this calls the FSharp.Core method
-#endif
 
-#if FX_NO_WEB_CLIENT
-#else
     [<AutoOpen>]
     module WebClientExtensions =
         open System.Net
@@ -319,5 +285,3 @@ namespace FSharpx.Control
                 this.buildAsyncAction(
                     this.DownloadDataCompleted,
                     (fun token -> this.DownloadDataAsync(address, token)))
-#endif
-

src/FSharpx.Async/AsyncOperations.fsi

@@ -58,9 +58,6 @@ namespace FSharpx.Control
             /// Create an async that opens a <c>System.IO.FileStream</c> on the specified path, via a fresh I/O thread.
             /// Pass <c>options=FileOptions.Asynchronous</c> to enable further asynchronous read/write operations
             /// on the FileStream.
-#if FX_NO_FILE_OPTIONS
-            static member AsyncOpen: path:string * mode:FileMode * ?access: FileAccess * ?share: FileShare * ?bufferSize: int -> Async<FileStream>
-#else
             static member AsyncOpen: path:string * mode:FileMode * ?access: FileAccess * ?share: FileShare * ?bufferSize: int * ?options: FileOptions -> Async<FileStream>
 
             // Aims to take advantage of IO completion ports using FileStream.AsyncWrite and FileOptions.Asynchronous, so no FX_NO_FILE_OPTIONS version
@@ -71,20 +68,13 @@ namespace FSharpx.Control
             static member AsyncAppendAllText: path:string * txt:string * ?encoder:System.Text.Encoding -> Async<unit>
             static member AsyncAppendAllLines: path:string * lines:string array * ?encoder:System.Text.Encoding -> Async<unit>
 
-#endif
-
-#if FX_NO_WEB_REQUESTS
-#else
     [<AutoOpen>]
     module WebRequestExtensions =
         type System.Net.WebRequest with 
             /// Return an asynchronous computation that, when run, will wait for a response to the given WebRequest.
             [<System.Obsolete("The extension method now resides in the 'WebExtensions' module in the F# core library. Please add 'open Microsoft.FSharp.Control.WebExtensions' to access this method")>]
             member AsyncGetResponse : unit -> Async<System.Net.WebResponse>
-#endif
-    
-#if FX_NO_WEB_CLIENT
-#else
+
     [<AutoOpen>]
     module WebClientExtensions =
         type System.Net.WebClient with
@@ -121,5 +111,4 @@ namespace FSharpx.Control
             member AsyncDownloadFile : address: System.Uri * fileName: string -> Async<unit>
 
             /// Returns an asynchronous computation that, when run, will wait for the download of the specified resource as a data buffer.
-            member AsyncDownloadData : address: System.Uri -> Async<byte[]>
-#endif
+            member AsyncDownloadData : address: System.Uri -> Async<byte[]>

src/FSharpx.Async/AsyncStreamReader.fs

@@ -34,14 +34,13 @@ type AsyncStreamReader(stream:Stream, encoding:Encoding, detectEncodingFromByteO
 
         if not stream.CanRead then
             invalidArg "stream" "stream not readable";
-#if FX_NO_FILESTREAM_ISASYNC
-#else
+
         match stream with 
         | :? System.IO.FileStream as fs when not fs.IsAsync -> 
             invalidArg "stream" "FileStream not asynchronous. AsyncStreamReader should only be used on FileStream if the IsAsync property returns true. Consider passing 'true' for the async flag in the FileStream constructor"
         | _ -> 
             ()
-#endif
+
         if (bufferSize <= 0) then
             raise <| new ArgumentOutOfRangeException("bufferSize");
 
@@ -125,8 +124,7 @@ type AsyncStreamReader(stream:Stream, encoding:Encoding, detectEncodingFromByteO
                 encoding <- new UnicodeEncoding(true, true); 
                 compressBuffer(2);
                 changedEncoding <- true; 
-#if FX_NO_UTF32ENCODING
-#else
+
             elif (byteBuffer.[0]=0xFFuy && byteBuffer.[1]=0xFEuy) then
                 // Little Endian Unicode, or possibly little endian UTF32
                 if (byteLen >= 4 && byteBuffer.[2] = 0uy && byteBuffer.[3] = 0uy) then
@@ -136,19 +134,17 @@ type AsyncStreamReader(stream:Stream, encoding:Encoding, detectEncodingFromByteO
                     encoding <- new UnicodeEncoding(false, true); 
                     compressBuffer(2);
                 changedEncoding <- true;
-#endif
             elif (byteLen >= 3 && byteBuffer.[0]=0xEFuy && byteBuffer.[1]=0xBBuy && byteBuffer.[2]=0xBFuy) then
                 // UTF-8 
                 encoding <- Encoding.UTF8; 
                 compressBuffer(3);
                 changedEncoding <- true; 
-#if FX_NO_UTF32ENCODING
-#else
+
             elif (byteLen >= 4 && byteBuffer.[0] = 0uy && byteBuffer.[1] = 0uy && byteBuffer.[2] = 0xFEuy && byteBuffer.[3] = 0xFFuy) then
                 // Big Endian UTF32 
                 encoding <- new UTF32Encoding(true, true);
                 changedEncoding <- true; 
-#endif
+
             elif (byteLen = 2) then
                 _detectEncoding <- true; 
             // Note: in the future, if we change this algorithm significantly,

src/FSharpx.Async/AsyncWorker.fs

@@ -10,8 +10,6 @@ namespace FSharpx.Control
     open Microsoft.FSharp.Control
     open Microsoft.FSharp.Collections
 
-#if FX_NO_SYNC_CONTEXT
-#else
     type AsyncWorker<'T>(p : Async<'T>,?cancellationToken) = 
 
         let cts =
@@ -63,6 +61,3 @@ namespace FSharpx.Control
         member x.Completed  = completed.Publish
         member x.Canceled   = canceled.Publish
         member x.Error      = error.Publish
-
-
-#endif

src/FSharpx.Async/AsyncWorker.fsi

@@ -8,8 +8,6 @@ namespace FSharpx.Control
     open System.Threading
     open Microsoft.FSharp.Control
 
-#if FX_NO_SYNC_CONTEXT
-#else
     type AsyncWorker<'T> =
         new : Async<'T> * ?asyncGroup: CancellationToken -> AsyncWorker<'T>
         member ProgressChanged : IEvent<int> 
@@ -18,6 +16,4 @@ namespace FSharpx.Control
         member Canceled : IEvent<OperationCanceledException> 
         member RunAsync : unit -> bool
         member ReportProgress : int -> unit
-        member CancelAsync : ?message:string -> unit
-
-#endif
+        member CancelAsync : ?message:string -> unit

src/FSharpx.Async/Observable.fs

@@ -280,11 +280,7 @@ module Observable =
           async {
               let! cToken = Async.CancellationToken
               let token : CancellationToken = cToken
-              #if NET40
-              use registration = token.Register(fun () -> remove())
-              #else
               use registration = token.Register((fun _ -> remove()), null)
-              #endif
               return! workflow
           })
 
@@ -320,11 +316,7 @@ module Observable =
           async {
               let! cToken = Async.CancellationToken
               let token : CancellationToken = cToken
-              #if NET40
-              use registration = token.Register(fun () -> remove())
-              #else
               use registration = token.Register((fun _ -> remove()), null)
-              #endif
               return! workflow
           })