There are plenty of things. From real-world experience, F# code ends up taking a bit less than half the amount of lines as C# does. More interestingly, the number of type annotations can be as little as 1/20th as in C#.

The benefit comes from that many "small" things you do in C# become much nicer in F#:

C#:

  int target;
  int someValue;
  if (dict.TryGetValue("key", out someValue)) {
      target = someValue * 100;
  } else {
      target = 42; // default
  }

F#:

  let target = match dict.TryGetValue "key" with
               | true, x -> x * 100
               | _	   -> 42 // default

Not only is the code more concise in F#, we get another benefit too. The temporary value x, needed because of the use of out params in C#, no longer exists in the F# version. In C#, this temp val escapes its needed scope - it should only be needed in the branch where it's used, but instead it's now a normal local.

A more large scale win is any async code. In F#, you can use the async workflow (monad), and with 1 character (!), you make the compiler emit code that'd take at least 10 extra lines in C#. Inside an async workflow, a let! (example: let! foo = bar.AsyncGetResponse()) is like calling bar.BeginGetResponse, bar.EndGetResponse, while preserving the current exception handlers and all locals. It makes heavily async code trivial to write, where in C#, it's near impossible.