F# 语法糖

Question

F# clearly contains a lot of things that are syntactic sugar, and as I try to learn it--without the aid of a book--I am overwhelmed by the sheer variety of syntax. Is there a simpler "core" language hidden behind all that syntactic sugar? Is there a cheat sheet list of the syntactic sugars and how they map to the core language?

And hey, is there a reason F# requires a different "assignment" operator for function definitions than for lambdas, or was it a random decision? eg "let inc x = x+1" vs "fun x -> x+1"

Answer 1

A great deal of F# syntax comes from OCaml - many OCaml programs will compile and run in F# with no changes.

Good starter links:

http://msdn.microsoft.com/en-us/fsharp/default.aspx

http://en.wikibooks.org/wiki/F_Sharp_Programming

http://lorgonblog.spaces.live.com/blog/cns.701679AD17B6D310?887.entry?_c=BlogPart

Answer 2

Along with Brian's links, I'd like to pass along links to my own blog series, Why I Love F# , which covers some of the basics.

With regard to your second question, "let inc x = x+1" vs "fun x -> x+1" are two ways of expressing a function, but only the first one uses the assignment operator. In fact,

let inc x = x + 1

Is equivalent to:

let inc = (fun x -> x + 1)

The first is shorthand for the second, but the second might illuminate how all functions in F# are really lambdas bound to names.

Answer 3

F#, barring .NET interop, seems quite simpler than, say C#. (Not really picking on it in particular, but since it's another popular .NET language...)

Take F# functions, for instance:

• There's no magic "void" type-thats-not-really-a-type
  • Hence everything is an expression
• All functions are unary
• Functions are first class type

Right there you have a function system that's vastly easier than, say, C#, where void creates a special case, and there's no generalization possible over all functions.

As to your specific question, with "let fx = x" versus "let f = fun x -> x", that's probably an inherited trait from ML. (I don't see any particular reason why it couldn't be "let f = fun x = x", except that perhaps it'd be more confusing and perhaps make the grammar more complex?. (Personally I'd prefer "let f = \xx".)) Anyways, while in most cases they are equivalent, sometimes you must define a syntactic function instead of a function value.

.NET interop can, unfortunately, make things a bit more complicated, although probably not more or much more than other .NET languages.

Answer 4

Only one of the two expressions you mentioned uses an assignment operator.

This defines a function bound to the identifier "inc" which takes a single argument of type int and returns the argument +1.

let inc x = x + 1;

This on the other hand, is an expression which represents a lambda. It is bound to no identifier cannot exist solely by itself. It must be part of a larger expression.

fun x -> x + 1

Answer 5

If you are looking for a cheat sheet for F#, this is the one that I use on a regular basis.

fsharpcheatsheet.pdf

It doesn't cover everything, things like Units of Measure or quotations, and doesn't talk about the various libraries, but it does cover a lot of the syntax.

Answer 6

http://www.samskivert.com/code/fsharp/fsharp-cheat-sheet.pdf

It's a pretty comprehensive cheat sheet that has helped me out a lot with learning F#

Answer 7

Notice that you can apply directly a lambda in an expression.

let i = (fun x -> x + 1)0  //i equal 1