We're in the process of nailing down the final details of the next release of F#. It will be release 1.1.11.3 (or so)

If there are any issues that you think should absolutely be dealt with in this release please let us know by emailing us directly at fsbugs AT microsoft DOT com

The current change list reads as follows (not all entries are yet fully documented):

Optimizations and Code Quality. Fewer locals are now produced in many situations where inlining occurs. This improves the quality of the end x86 code, allows the JIT to inline more often and reduces the size of the metadata in generated assemblies.

Extensible expr.[idx] syntax for string, array, dictionary and other access operations.. The syntax expr.[idx] is now shorthand for accessing the Item property on a type. This means that expr.[idx] can be used to perform lookups on essentially any .NET collection type.

Note: As with overloaded operators on integers, the types string and the array types do not in reality support efficient Item properties. However F# arranges things to give the appearance that they do.

Improvements to inference related to 'null' values. 'null' constraints have now been incorporated into the inference process.

Instance members on List, Option, Set.

Instance members now permitted on types that may use null as a representation.

Implementation of Structural comparison, equality and hashing now in F# code (hence easier to debug).

Multiple namespaces fragments now permitted in a single file, and multiple fragments can be constrained by a single signature..

Fixes to non-zero-bounded multi-dimensional arrays.

Overload Resolution when Multiple Overloaded Operators Exist. Some .NET support multiple overloads for the same operator, which must be resolved according to a process similar to the resolution of overloaded methods. F# uses constraints to handle operator overloading, and now resolves the choice between multiple overloads using essentially the same technique as is used to resolve method overloading. For example, the following overloads now resolve correctly:

1
2
3
4
5
6
7
8
9
10

let f1 (x:DateTime) (y:TimeSpan) : DateTime = x - y
let g1 (x:DateTime) (y:DateTime) : TimeSpan = x - y

// Return type is also sufficient:
let f2 (x:DateTime) y : DateTime = x - y
let g2 (x:DateTime) y : TimeSpan = x - y

// Just argument types are also sufficient:
let f3 (x:DateTime) (y:TimeSpan)  = x - y
let g3 (x:DateTime) (y:DateTime)  = x - y

Type Qualified Disciminator Names. Ambiguity between constructors of a discriminated union can now be resolved by using the type-qualified path to the discriminator, for example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

type XY = X | Y
type YZ = Y | Z

let y1 = XY.Y
let y2 = YZ.Y

let f xy = 
	match xy with 
	| XY.X -> "X"
	| XY.Y -> "Y"

let g yz = 
	match yz with 
	| YZ.Y -> "X"
	| YZ.Z -> "Y"

The same is true of record field names, though this has been the case for some time now.

The --base-address flag. Base addresses indicate the default loading address for DLLs within a memory space. Loading a DLL at a default location can reduce the need for 'fixups' that occur when a native DLL gets relocatred. Native DLLs occur with F# code if you use NGEN with your F# DLLs, and it is recommended that you use an approriate base address if using NGEN and rebasing conflicts occur. Various tools and debuggers are available on the web to help determine if rebasing is occuring.

Use F# with Microsoft internal or self-built versions of the CLI. Some Microsoft internal or self-built implementations of the CLI have unusual, non-standard names such as v2.0.x86chk. The --cli-version flag can now be used to specify such a version.

Minor improvements and Bug Fixes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

574	F# Compiler	issue with top level 
                           mutables (fsi.exe), reported by Andrew Fitzgibbon
389	F# Perf	        Printf implementation allocated too many closures
594	F# Compiler	tyvar lookup failed in ilreflect
595	F# Interactive	F# Interactive code generation bug when 
                            closures used inside interface implementations
596	F# Interactive	F# Interactive code generation bug: 
                           Implementing generic interfaces does not always 
                           correctly work around Reflection.Emit limitations
586	F# Compiler	local mutables spilled into other locals prior to use
588	F# Compiler	expr of constructor argument is not typed-expr
587	F# Compiler	poor error message on for i = 0 to 10 do .. done expr
590	F# Compiler	match exprA,exprB with ....  allocates tuples
592	F# Compiler	poor error message when a constructor is too generic
582	F# Compiler	fsi prints types of the latest interaction with full path
581	F# Compiler	Problem with pickling: Quotation <@ 1.3 @> gives NaN
576	F# Perf	        Reduce numer of generated IL locals
566	F# Compiler	interface inheritance/extension not being printed correctly
516	F# Compiler	permit C# events to be used as first class IEvent objects from F#
471	F# Compiler	Eliminate unnecessary .cctors