Partager via

Detailed release notes for 1.1.12.3

  • Article

Detailed release notes for 1.1.12.3

 

Collected changes between v1.1.11.12 and 1.1.12.3

Lightweight syntax option. Are you sick of writing in? The #light option makes the use of certain keywords such as in optional by using indentation. See the informal language specification for details, as well as the ConcurrentLife sample and the Samples101 tutorial. Enable using #light.

First experimental cut at the Active Patterns. More on Don Syme's blog.

More modules in MLLib. Modules UInt8, Int8, Int16, UInt16 have been added.

More collections in Microsoft.FSharp.Collections. The Set and Map collections are now defined as object-oriented abstractions in Microsoft.FSharp.Collections. The corresponding MLLib modules are defined in terms of these OO abstractions.

Removed deprecated Stream module from MLLib. Minor updates to the LazyList module as a result.

--gnu-style-errors flag no longer accepts spurious integer argument.

Slight modification to overloading for +,*,/,mod.

In version 1.1.11 a slight change was made to the default overloaded signature for - operator to allow the return type to be unassociated to the two input types, as is required for overloading on the System.DateTime subtraction operator. This change was mistakenly applied to other operators, resulting in situations where type inference would report unexpected inference errors for fairly straight-forward floating point code.

Bug fixes.

     ---  F# Compiler -R clobbers DLLs with PDBs
    ---   F# Compiler no properties being generated for top level values
    605   F# Visual Studio VFSI scroll to caret does not always show input position
    643    F# Compiler internal warning when unpickling override of abstract member
    655 F# Compiler interface implementing methods marked private but included in modul_typ
    656  F# Compiler Runtime exception TypeLoadException method 'Specialize'... tried to implicitly override a method with weaker type parameter constraints
    645  F# Debug    problems setting breakpoints in inner functions (reported by Jack Palevich - thanks Jack!)
    647   F# Compiler lowercase constructors are incorrectly permitted
    654 F# Interactive  cannot declare delegate types interactively
    672  F# Visual Studio Unapplied methods should give signature of method overloads in error message
    671    F# Compiler -R feature overwrites .dll file with .pdb file
    670   F# Compiler protected access not permitted via member 'this' variables
    668   F# Language L-R type inference with (fun x -> x * x * 1.0)
    667    F# Language exceptions to carry line numbers?
    663     Fix broken codegen for generalized constrained polymorphic functions
    659    F# Visual Studio Intellisense does not work in a for .. to .. do line
    676    F# Visual Studio Inappropriate popup
    644 F# Language execution and inference for record expressions is not always left-to-right
    533   F# Release  proper uninstaller
    517   F# Compiler fsi.exe does not process #r/#I directives for files on command line
    678  F# Library  delete very old obsolete functionality fro the 'Set' module
    679  F# Library  Add object-oriented version of immutable 'Sets' to Microsoft.FSharp.Collections
    681  F# Visual Studio hardwhite intelisense
    682   F# Compiler field and property names with same name - allowed
    680    F# Visual Studio intelisense bugs
    665    F# Language exprs ending in semi-expr sequences cause confusion when ending constructs which are themselves semi separated.

Changes between v1.1.11.7 and 1.1.11.12

Copy-Local reference options DLLs that are not in the GAC must be copied to an application's directory prioer to execution. This is not currently well-supported by the F# Visual Studio mode. Thus the following options are now supported by the fsc.exe compiler and are especially recommended for use from Visual Studio:

   -R           DLL     both reference the given DLL and copy it to the output directory at the end of compilation
  --copy-local FILE    copy the given file to the output directory at the end of compilation

Note that -R = -r + --copy-local. Also these switches are not required by fsi.exe which is able to resolve and load DLLs from any location.

New Installer InstallFSharp.msi. This currently always installs to the Program Files directory.

New library module Microsoft.FSharp.MLLib.Native Helpers for native interop. See library documentation.

Minor breaking change for native pointers. The F# "'a nativeptr" is now compiled as the .NET type System.IntPtr for all 'a. .NET pointers such as "int*" are now represented by "ilsigptr" types. This cange is because although .NET has a notion of a "pointer type", used in some .NET signatures, these are not "real" types, since they can't be used within generic instantiations. This is very bad for C-interop F# code, which generates generic instantiations for function and tuple values. Thus, the F# 'a nativeptr type is now always compiled as System.IntPtr, regardless of 'a (it is not type equivalent as far as F# is concerend - this is just how the type is compiled. The pseudo-type 'a ilsigptr (IL Signature Pointer) is provided if you need to call a .NET signature using a pointer type.

COMPILED and INTERACTIVE supported as standard --define in F# Interactive and compiled code This is useful as some code fragments such as Application.Run() are only needed in compiled code. Also accessing things such as resources can vary between interactive and compiled code.

Type Inference corrections for fields and records

It is implicit in the F# informal specification that record constructions should use contextual left-to-right type information to help determine the type being constructed. This is now implemented, and makes it easier to use record syntax when record member names overlap.

Types are no longer inferred from uses of class field labels alone. Previously, defining a class "C" with a value field called, say "f" meant that "f" became a scoped record label. This meant that "expr.f" would infer the type of "expr" to be "C". This is still done for _record_ labels, but is no longer done for class field labels, and instead an annotation may be needed to constrain the type of "expr" based on left-to-right type inference. A helpful warning about the deprecation of this language feature is given when this occurs. This was always meant to be the intended treatment of inference for these constructs - it was an artefact of the initial implementation that inference for record field labels was treated in this way.

Various .NET generic constraints implemented .NET generics supports a number of somewhat adhoc constraints on the structural properties of types. It is necessary for F# to support these in order to emit correct and valid generic code and make sound use of F# libraries. The syntax of the constraints is:

    when 'a : struct       // any struct, with the exception of Nullable
   when 'a : not struct   // any reference type - note - this syntax is under revision
   when 'a : (new : unit -> 'a)   // default constructor

The following F#-specific constraint has also been added:

    when 'a : null          // any reference type that supports null according to the F# pseudo-enforcement rules for prohibiting the use of null with F# types
   when default 'a : <type>  // the variable will take the given value if not otherwise instantiated or generalized

Default constructors are called using the syntax:

    new 'a()

Where 'a should be related to another annotation in the same definition, e.g. an argument of the enclosing function. This constructs is compiled as a call to System.Activator.CreateInstance<'a>() .

Minor improvements and Bug Fixes

    573  F# Compiler list equality is not tail recursive.
   613  F# Library  List.combine and List.split are not tail recursive (reported by Ralf Herbrich - thanks Ralf!)
   615 F# Interactive  FSI reflection code throws TypeLoad error for type reference within the same interaction.
   602 F# Compiler name of type not reported in "member required" error
   120  F# Compiler Things stored in public static fields should only be accessible via properties
   495    F# Compiler SQL cannot load F# assemblies due to publically writable statics
   625  F# Compiler Poor error location for error messages related to 'new' in signatures
   626 F# Library  Add 'generate' methods to IEnumerable.
   628    F# Compiler nested ifdefs not always handled correctly (Reported by Jack Palevich - thanks Jack!)
   630 F# Compiler Error writing assembly with F# 1.1.11.7 (reported by Lewis Bruck - thanks Lewis!)
   631 F# Compiler System.MethodAccessException thrown by FSI.EXE (reported by Pierre Dangauthier - thanks Pierre!)
   634  F# Compiler object expression limitations: let bound object expressions not generalized (reported by Greg Neverov - thanks Greg!)
   640 F# Compiler record fields should be inferred from the known context type of the expression 
   639   F# Compiler class fields are contributing to the record field environemnt
   638 F# Compiler multiple constraints on type parameters not being correctly printed
   636   F# Compiler simple object expressions implementing interfaces should be allowed in "let rec" without generating an iniitalization graph warning
   632   F# Debug    smoother debugging needed for inner recursive functions
   648   F# Library  Documentation for printf codes for 64-bit integers is incorrect (reported by Richard Mortier - thanks Richard!)
   650   F# Compiler incorrectly permitting the declaration of interfaces that contain fields (reported by Robert Pickering - thanks Robert!)
   649  F# Compiler bug in quotation template filling for typed quotations (Reported by Tomas Petricek - thanks Tomas!)
   646   F# Compiler attributes on top level values not propagating to generated static fields, e.g. ThreadStatic (reported by Robert Pickering - thanks Robert!)
   645  F# Debug    setting breakpoints in inner functions sort of broken (reported by Jack Palevich - thanks Jack!)

Comments