[nem-en] Fwd: [fsharp] F# Meets Linq (blog posting), also F# 1.1.8.1

[Michal Moskal]

This may be of interest for anyone working on VSIP plugin.

---------- Forwarded message ----------
From: Don Syme <Don.Syme at microsoft.com>
Date: Jan 27, 2006 4:51 AM
Subject: [fsharp] F# Meets Linq (blog posting), also F# 1.1.8.1
To: F# List <fsharp at list.research.microsoft.com>







Dear F# List,



F# 1.1.8.1 has been up on the F# website for some time, but there is
so much to say about it that I didn't do a release announcement, but
rather will write several blog entries covering the different
material.



I've just posted the first of these giving a taste for how F# will
approach LINQ programming – the blog entry is at



http://blogs.msdn.com/dsyme/archive/2006/01/27/FSharpMeetsLinqOne.aspx



This only touches on the really interesting part of the story – the
metaprogramming support through quoted expressions, new in 1.1.8.1.
I'll be following up with more details on that soon.



A brief summary of the other changes in 1.1.8.1 is as follows:

·         Expression Quotation now called Microsoft.FSharp.Quotations
contains a range of functionality related to "lifted expressions",
i.e. expression quotation, which is a form of meta-programming. This
is still under development, and some important functionality is
missing or incomplete, but is extensively used in the LINQ sample that
is also available in the release.

Math library redesign. A new module Microsoft.FSharp.Math.Notation has
been added, containing notational conveniences such as the values
matrix, and vector. Microsoft.FSharp.Math.Notation.Generic is also
present.

The primary type definitions have been moved to Microsoft.FSharp.Math.Types.
The modules previously called MatrixOps etc. are now called Matrix etc.
The suffixes have been dropped of value names like mapM; getV. Instead
qualified names such as Matrix.map and Vector.get should be used.
The names create have been changed to the more standard init.
Some functions related to row vectors have been deleted
A new module Microsoft.FSharp.Math.Compatibility.MATLAB has been
added, to contain functions that make programming in F# a little more
like programming in MATLAB.
Renamed Microsoft.FSharp.Experimental.Reflection tp
Microsoft.FSharp.Reflection.

·         Expression quotation library redesign and cleanup. Now
called Microsoft.FSharp.Quotations.

·         HTML library manual pages now included in the release and on
the Microsoft Research website.

·         HTML documentation generation with fsc.exe. Look for the
--html* flags in the advanced flags. Documentation is given using
"///" comment markers prior to modules, types, values and exceptions.

·         Bug Fixes - Fix some problems with the Visual Studio mode.
Some files were missing.

·         LINQ Sample. The sample samples\fsharp\FLinq shows how F#
can work with the Language-Integrated-Query libraries currently under
development at Microsoft.

·         Source Release. source/... now finally includes all the
source code to the F#, the library and the tools, as long promised.
Much source has been included in previous releases, but we'd just
never got around to including the whole bundle.  NOTE: Some problems
with the Makefile prevent it from compiling in this release – these
will be fixed in the next release.  General comment: The source has
its many quirks and there are many things we will be cleaning up - if
it's ugly then please be merciful and ignore it – we were in a rush.

·         Visual Studio mode: (The source for the VS plugin is not yet
included, though a crucial file 'fsharp/vs/service.ml' is - this has
the key functionality that implements the line-by-line lexing,
typechecking cache etc.)

·         Argument name annotations for documentation purpose in
signatures. Arguments can be labelled for documentation purposes, in
signature files (.mli/.fsi) only. Note this is not the same os OCaml
labelled arguments (which permit labels to be used at the callsite).

·         First class uses of the 'unit' type now compiled to
Microsoft.FSharp.Unit. Previous versions of F# compiled the unit type
to System.Object. This has been changed to give better fidelity for
runtime types, especially of function values. Note this will break C#
2.0 code that has not been using delegates of type System.Action</tt>
as the way of creating function types.

·         Library Updates as discussed recently on the F# list

  ---
 You are currently subscribed to fsharp as: malekith at pld-linux.org
 To unsubscribe send a blank email to
leave-fsharp-10729U at list.research.microsoft.com Please see our Privacy
Statement:
 http://list.research.microsoft.com/privacy/privacy.htm

--
   Michal Moskal,
   http://nemerle.org/~malekith/