The full change list for F# 1.1.11.6 is below. Here's the list of fixes we've made between F# 1.1.11.6 and F# 1.1.11.7: -- Permit the use of lambdas taking multiple tupled arguments within quotations. -- Fix integer formats 0b101001 and 0o101030 in fsi.exe (thanks to Robert Pickering for this one) -- Fix inlining of composition operator -- Add signature to 'prim-types', hiding the presence of the "Basics" module (thanks to James Margetson and Richard Mortier for this one) -- Fix optimization of integer keys for hash tables
Changes for F# 1.1.11.6:
F# Language: Namespaces.. Multiple namespaces fragments now permitted in a single file. Multiple fragments can also be constrained by a single signature. Multiple different files within an assembly may also contribute to the same namespace. For example:
/// Put the concrete type definition under 'Types' namespace Microsoft.FSharp.Math.Types type BigComplex = { r: bignum; i: bignum } /// Now add a type abbreviation and module under the main namespace namespace Microsoft.FSharp.Math type bigcomplex = Microsoft.FSharp.Math.Types.BigComplex module BigComplex = begin open Microsoft.FSharp.Math.Types let complex r i = { new BigComplex with r=r;i=i } end
F# Language: Use of null values no longer require type annotations. null values previously required immediate type information. Instead, null constraints have now been incorporated into the inference process, meaning that the type associated with the use of the null value must simply be resolved at some point in the type inference scope. This means far fewer type annotations are needed when passing 'null' values to .NET.
F# Language/Library: Implementation of Structural comparison, equality and hashing now in F# code (hence easier to understand and debug). See the file prim-types.fs in the library for the implementation of the definition of structural and physical equality, used if all other optimization techniques fail.
F# Language: More General Type Checking Rule for Class Field Access and Setting. Accessing and setting a class field previously required the object being accessed to have precisely the type of the class containing that field. This has been liberalized so that the object can have any subtype of the class containing the field. This change may affect code that uses signatures, because the inferred type of a function may be more general. For example, given
type MChan = class val mutable sndLst : MChan list end let linkMChan src dstLst = src.sndLst <- append src.sndLst dstLst
the inferred type of linkMChan was previously
val linkMChan : MChan -> MChan list -> unit
but is now the more general
val linkMChan : #MChan -> MChan list -> unit
where as usual the # indicates that any subtype is accepted as the first argument. If no subtyping is required then a rigid type annotation may be used in the implementation:
let linkMChan (src : MChan) dstLst = src.sndLst <- append src.sndLst dstLst
F# Language: Overload Resolution when Multiple Overloaded Operators Exist. Some .NET types 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:
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
F# Language: 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:
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.
New F# Samples: DirectX 3D Visualization, WebCrawl. See the 'samples' directory.
F# Library: Warnings now given that 'Stream' will be renamed. This module has been renamed 'LazyList'.
F# Library: BigNum performance improvements. Major implementation improvements and tuning the cross-over between the multipliers.
F# Library: Additional Math.Complex operations.
F# Interactive and Library: Default floating point format for generic printing now 'g10'. i.e. for print_any, output_any, etc. and F# Interactive.
F# Interactive: --codepage switch now accepted by fsi.exe. This controls the codepage used to read the input files. The switch does not yet apply to fsc.exe.
F# Library: Primitive structural comparison and hashing routines moved. These were in Microsoft.FSharp.Primitives.CompilerPrimitives but are now under Microsoft.FSharp.LanguagePrimitives. After a review of the library and as part of the re-implementation of structural comparison and hashing in F# code (see below) the primitive functions used for polymorphic recursive calls in structural comparison and hashing have been moved to a new module Microsoft.FSharp.LanguagePrimitives. These functions may have been called recursively from some user code. The section in the language specification has been updated to reflect this.
F# Compiler: 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 Item properties in the underlying .NET metadata. However F# arranges things to give the appearance that they do.
F# for Visual Studio: Minor improvements
F# Interactive: Suffixes .fsx and .fsscript now accepted.. These are useful for F# Interactive scripts.
F# Interactive: Formatting options may now be specified. There is an fsi object, of type InteractiveSession, available in the top-level.
namespace Microsoft.FSharp.Compiler.Interactive type InteractiveSession with member FloatingPointFormat: string with get,set member FormatProvider: System.IFormatProvider with get,set member PrintWidth : int with get,set member PrintDepth : int with get,set member PrintLength : int with get,set member ShowProperties : bool with get,set member ShowIEnumerable: bool with get,set member PrintIntercepts: (StructuredFormat.IEnvironment -> obj -> StructuredFormat.Layout option) list with get,set member AddPrinter: ('a -> string) -> unit ... end
Here's an example of it's use:
> fsi;; > fsi.FloatingPointFormat <- "%.3";; > fsi.PrintWidth <- 80;; > fsi.AddPrinter(fun (x:System.DateTime) -> sprintf "%Ld" x.Ticks);; > System.DateTime.Now;; > fsi.ShowIEnumerable <- false;; > fsi.ShowProperties <- false;;
F# Compiler: 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 relocated. Native DLLs occur with F# code if you use NGEN with your F# DLLs, and it is recommended that you use an appropriate base address if rebasing conflicts occur when using NGEN. Various tools and debuggers are available on the web to help determine if rebasing is occuring.
F# Compiler and F# Interactive: 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.
F# Interactive: Minor improvements
Minor improvements and Bug Fixes
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 number of generated IL locals 566 F# Compiler interface inheritance/extension not being printed correctly 471 F# Compiler Eliminate unnecessary .cctors --- Fixes to printing and Array2 module for non-zero-bounded multi-dimensional arrays. --- Instance members now permitted on types that may use null as a representation. They are compiled as static members. --- Fields in super classes not accessible (reported by Ralf Herbrich - thanks Ralf!)