f#-3.0

I'm using VS11 Beta on Win 8 Consumer Preview. After install VS11 Beta I have F# 3.0 SDK installed. But I'm not able to find a compatible FSharp.PowerPack.dll as CodePlex only provides PowerPack for F# 2.0. Any idea how to deal with this? Brian You can compile the PowerPack sources on your own (against F# 3.0), to make your own copy of the library. Alternatively, I think a binding redirect in your final foo.exe.config, along the lines of https://stackoverflow.com/a/9648673/19299 but redirecting 2.0.0.0 (that PowerPack uses) to 4.3.0.0 (in VS11 SDK) will also work. In addition to what Brian

I want to replace GetPixel and SetPixel using LockBits method, so I came across this F# lazy pixels reading open System.Drawing open System.Drawing.Imaging let pixels (image:Bitmap) = let Width = image.Width let Height = image.Height let rect = new Rectangle(0,0,Width,Height) // Lock the image for access let data = image.LockBits(rect, ImageLockMode.ReadOnly, image.PixelFormat) // Copy the data let ptr = data.Scan0 let stride = data.Stride let bytes = stride * data.Height let values : byte[] = Array.zeroCreate bytes System.Runtime.InteropServices.Marshal.Copy(ptr,values,0,bytes) // Unlock the

This active pattern compiles with F# 2.0: let (|Value|_|) value = // 'a -> 'T option match box value with | :? 'T as x -> Some x | _ -> None but, in F# 3.0, emits the error: Active pattern '|Value|_|' has a result type containing type variables that are not determined by the input. The common cause is a [sic] when a result case is not mentioned, e.g. 'let (|A|B|) (x:int) = A x'. This can be fixed with a type constraint, e.g. 'let (|A|B|) (x:int) : Choice = A x' I tried: let (|Value|_|) value : 'T option = ... and: let (|Value|_|) (value: 'U) = ... How can it be fixed? Environments: Visual

Given a trivial sequence of tuples, and a parallel one using F# PowerPack's PSeq: let a = Seq.singleton (1,"a") --> val a: seq<int * string> let b = a |> PSeq.map id --> val b: pseq<int * string> Now I'd like to create a .Net BCL dictionary from them: let bd = b.ToDictionary(fst, snd, HashIdentity.Structural) let ad = a.ToDictionary(fst, snd, HashIdentity.Structural) let ad2 = a.ToDictionary(fst, snd) let ad3 = a.ToDictionary((fun (x,y) -> x), (fun (x,y) -> y), HashIdentity.Structural) While let bd works, let ad does not compile as it fails to infer types and convert to BCL's Func correctly.

I was pretty comfortable with how async cancellations where done in C# with the TPL, but I am a little bit confused in F#. Apparently by calling Async.CancelDefaultToken() is enough to cancel outgoing Async<'T> operations. But they are not cancelled as I expected, they just... vanishes... I cannot detect properly the cancellation and tear down the stack properly. For example, I have this code that depends on a C# library that uses TPL: type WebSocketListener with member x.AsyncAcceptWebSocket = async { let! client = Async.AwaitTask <| x.AcceptWebSocketAsync Async.DefaultCancellationToken if