I guess most people around here are C/C++/C# or Java developers but we are mature enough to know that not every language has to look like C.

And guess what: F# follows a heritage from OCaML, ML, ... straight to LISP and LISP is actually older than C - OK you don't have so many ";" in LISP but you get a lot '(' and ')' ;)

So what? Complain why C uses the ugly "{" instead of the historical "(" ?

Why even complain about some meaningless stuff like the presence or absence of a terminal symbol like ';' when we should discuss things like the demand of the comunity for actual type classes in F# ;)

Just give F# and FP a chance (just like you gave one to HM :P ) - I don't think you will be disappointed as soon as you actually understood the languague and functional programming.

FSEnthusiast, F# syntax is very flexible. You can end statements with a semi-colon, or a a end of line, or both. But usually, we try to avoid side effects, and we don't use statements.

You're allowed to specify type informations (almost) anywhere you want, or you can let the compiler guess them. It's up to you.

Light syntax, where spaces are significant, seems to be more inspired from Python (although, Python's one is quite poor) and Haskell, than from VB. Semi-colons were introduced in C for parsing reasons: it was for the compiler, and not really for the programmer. To me they are quite noisy, they are useful only when two statements are on the same line.

Banshee, most languages allow semi-colons for sequences of instructions. Look at this page (it's very interesting, even if some F# information is a bit outdated now): [link:rigaux.org]

Laurent.

It's natural to have a separator such as semi-colons in imperative languages, such as C and its offspring. Programs in these languages are sequences of operations which must be executed in exactly the order in which they are written. Programs are essentially lists of operations, and I personally think that semi-colons make good separators in lists.

Functional languages inherit from the mathematical notation, which is based on formulas and expressions. The order in which parts of an expression is evaluated is not so important. Actually, some parts may not even be evaluated at all! Functional programs have less of a linear structure, more tree-like. In this context, operators play the role of separator, and there is no single symbol that will fit all situations.

Now, you may point out that C supports expressions, and F# supports imperative constructs, so both have operators and separators, but they still have different origins, which is reflected by their syntax.

My background is also in C++ programming, F# is my first functional language. I was also a bit repelled by the syntax at first, but I no longer mind. I'm really starting to appreciate its conciseness, actually. After you have learned more about F# you may see why the semi-colon no longer occupies the center of the stage in F#. For instance, you may notice that |> starts appearing a lot in your code, somewhat replacing ;

Well, the reason I picked the semicolon character while stating that F# could've used it to end statements is that I can see that F# has elements of C/C++ in it, like printf and the underscore embedded in certain keywords (or library functions, or whatever). And C/C++ use semicolons to end statements, which is certainly a more precise syntax than some whitespace. How would some long statements look on a text editor like notepad, or if such F# code is printed on paper?

It would be even more immediately obvious that the statement has ended in F# than in C++, because in F# as soon as the indentation shifts to the left, the statement is over. You don't even have to examine the code, it just jumps out at you. Which of the following, for example, is easier to find the statement breaks in?

1

   int result=4; ++result; int r2 = 0;  if (result < 7) r2=4 else (r2 = (int)System.Math.Sqrt(result*result*2));  System.Console.WriteLine("Result is {0}!", r2);

1
2
3
4
5
6
7
8

   let result = 4
   let r2 = 
       let plus_one = result+1
       if (plus_one < 7) then 4
       else System.Math.Sqrt(plus_one*plus_one*2)
   printfn "Result is %d" r2

You might say it's bad programming practice to do the first in C++, which it definitely is, but it's possible, whereas in F# it's not even legal to do something like that. Furthermore, you can figure out where every single statement ends trivially, by just looking at all lines that have the same indentation level.

Lots of people still use printed books to learn, and using whitespace to end statements introduce ambiguity into code displayed in such medium.

I categorically disagree. In fact, I would argue the exact opposite. When you read messages from someone who never uses paragraphs, it's extremely difficult to read. It's so difficult to read that it even has its own name (wall-o-text). As soon as you introduce a few paragraph breaks, it becomes extremely easy to read. You dont' even have to search for where the paragraph ends, because glancing at the page for about 10 milliseconds would see that it's exactly where the big empty line is.

if you're a C/C++/C# or even a Java developer, you would understand why semicolons can be helpful.

I've been a C++ developer for 12 years :-/ Aside from C#, which I don't even consider since it's so easy for a C++ programmer, F# is the first language I have put any serious amount of effort into learning.

And for that reason, I hate F#'s way of declaring identifiers without attaching proper types to them - there's more ambiguity right there. But I can see that there's a way around that, and that's what I'll use. I've noticed other such problems in the language elsewhere, but I can't be bothered to spell all that out here.

Honestly I think you're just missing the entire point of F#. There's no ambiguity whatsoever in not attaching proper types to variable identifiers. Literally, none. F# is more strongly typed than C++, Java, and C#. The difference is that in a language like C++, you have to actively think about when to make a function into a template function. There are plenty of people who have written this function in C++

1

int max(int a, int b) {   (a>b) ? a : b;   }

when it would have been better if they had used a template. That's a trivial example, but it applies for just about anything. F# automatically "templatizes" everything that it is technically possible to templatize, and it does so while still remaining more type safe than C++.

Also, for the record, I really like some heavy metal music :P

Well, one thing is for sure. F#'s certainly getting a broader audience.