Now that you’ve gained a basic understanding of F# tooling and have spent a little time writing some (admittedly simple) F#, it’s time to learn about the core elements of the F# language. Many of the concepts and elements that you learn in this chapter are what I would call “cross-cutting”—they don’t have specific effects in any one type of application or use case but form the underpinnings of almost everything else in the language. So, it’s important to make sure you learn these concepts thoroughly. The first two, syntax and type inference, will give you an insight into the structure and look and feel of the language, while the second half of this chapter will help you understand how you’ll be structuring and composing applications together and building basic routines at a fundamental level.
The core syntax rules of a language say a lot about the “feeling” of the language. For example, some languages may focus on being highly explicit and verbose (I would, for example, put Java into this category); others may be terse and powerful but require more investment up front to understand what’s going on (Haskell, perhaps). Others might be lightweight with the intention of getting out of your way but don’t allow you to easily define the rules of what you’re trying to achieve (Go and, perhaps, Python).