Some tips that helped me be a better beginning F# programmer:

Tip # 1: When it doubt, make it explicit.

F# is a wonderful language. You can write very terse programs, and F# will infer all sorts of things (types, statement boundaries) for you. However, until you have developed a completely accurate mental model of F#'s syntax and type inference rules you will be surprised and frustrated by how F# interprets your code.

When trying to debug some F# code, or even just to get it to compile, it really pays to make the code explicit:

* Add type annotations to function arguments and let declarations. This will help you fix type inference problems by isolating the problem to a specific function.

* Add double semicolons at the end of every global expression. This helps you track down syntax errors by limiting the scope of the syntax error to the expression where they actually occur.

* Break up complicated F# expressions into a series of "let" statements. This helps track down errors by making the evaluation order explicit. (This is especially helpful with "XXX is not a function and cannot be applied" errors.)

* Add parentheses to disambiguate complicated expressions. (This isn't quite as useful as using extra lets, because it's more error prone. But it's less to type.) When placing parens remember that f(g(x)) in C would be (f (g x)) in F#.

Tip #2: Everything's an expression. Even statements

This insight (which I read on a "Java developer's guide to O'Caml", but I haven't been able to find the original document again.) is very helpful for understanding where to place semicolons, and when you need to add parenthases to group statements. Think of the semicolon as a binary operator that takes two expressions as arguments, and evaluates the left expression, which must evaluate to unit, then evaluates the right expression and returns its result.