Here are a couple features that I'd like to be considered for a future release of F#.

First off, scoped types - e.g.

let simpleConversation () =
type Answer =
| Yes
| No
.....

In this case, the type Answer would only be visible inside the scope of simpleConversation. This would help with encapsulation, where you might have a special purpose discriminated union that's only used in one place, such as for a command line parser. If there's an underlying problem with having locally defined types with the CLR, the simple thing to do would be to enforce it in the compiler via name mangling or similar. Better yet, it could generate a namespace for any given scope so that the types would not collide and would be invisible to external languages.

Second, remove the case limit for multi-case active patterns. Or at very least, allow something of the form:

let rec (|case1|_|) = ...
and rec (|case2|_|) = ...
and rec (|case3|_|) = ...
....

Active patterns are a very powerful construct, and are well suited for things like lexing/parsing, where a single recursive multi-case active pattern could capture a syntax tree for an entire program. Moreover, it does it in a nice declarative fashion! Thus, it's a disservice to restrict them to a single usage pattern.

Third, adjust order of operations for the . operator. The line of code

branch |> tree.prune

should be equivalent to

branch |> (tree.prune)

and not

(branch |> tree).prune

Since the period should be seen as less of an operator and more a name extension - tree.prune is a well defined atomic entity.