As you may have guessed from the title, I’ve started doing some work with F#. Initially I was somewhat reluctant to go down the F# path because some of the more interesting aspects of the other functional languages I’ve been exploring are not present…specifically the type systems behind Scala and Haskell, the laziness of Haskell, and the concurrent programming model of Erlang. In spite of these perceived downfalls, there were some definite plusses, namely interoperability with everything .Net, immutability by default, and the wonderful concise programing model of a functional language.
So with these benefits in mind I set about figure out what F# was all about. The language itself is based strongly on OCaml, and I’ve not had any experience with OCaml, so I was unsure what to expect. I decided to find a book on the subject, and I wish I could tell you for sure which one it was, but it was long ago, and for some reason when I look at all of the F# books on Safari none of them seem to fit the bill…The closest seems to be Expert F# 2.0, so we’ll assume that one was it for now. Regardless, I read the entire thing over the course of about 3 days (started on a Friday, and had made my way through by Sunday). I didn’t go through any exercises, or really try to write any code along the way, since I really just wanted to figure out what the language was all about. I should point out that I’ve tried at least once before to make my way through an F# book, and didn’t have much luck…this time round it was smmoooooth. I think the biggest reason was that I already had a pretty solid grasp of the core concepts in functional languages. Things like functional composition, pattern matching, and working with immutable data types are central to just about every functional language, and F# is no different, so my learning experience was really just a matter of mapping those concepts onto the correct syntactic elements in my head. By the time it was all over I felt pretty comfortable with the basics of the language.
Shortly after reading the book I decided to actually try writing something real and useful…this proved to be a bit more of a challenge. There are a few reasons for this…a big part was that organizing a functional project is different than organizing an OO project. This was complicated by the fact that the first task I set myself on was re-writing something I had in C# in F#. This was supposed to be more than just a syntactic translation, but also an attempt to see if my hunch that the problem being solved was effectively a functional problem, and so would lend itself well to a real functional language. The problem was I was used to thinking about the problem in terns of the classes I had already created, and in F# those concepts were not there. Before long, though, I had adjusted my thinking, and the more time I spent working on the problem the more I found myself enjoying F#. After that initial experience (which was mostly academic, in that it was not intended to go “live”) I found myself wanting to explore more with the language, and so I’ve been looking for reasons to use it. I’m not going to go into all of the ways I’ve managed that here, but I did want to share some observations:
- My initial reluctance based on the perceived drawbacks were largely my own naivety. While it is true that there are no higher-kinded types, and therefore no type constructors, this does not make the programing experience that much worse. Granted there are some kinds of things that will be duplicated, which folks using Haskell would be able to do away with by harnessing the power of the type system, but this does not make F# useless by any stretch. As a matter of fact F# exposes some capabilities of the CLR that C# does not, including being able to specify wildcard types, which allow you to say “I have a parameterized type, but I don’t care about the specific type of the parameter”, and even some Structural Typing, which provides a way to constrain types by specifying the methods those types should have.
- The let construct is deceptively simple when you first encounter it. Initially it seems like just a way to specify a variable or function name…it becomes interesting though when you realize that the fact that there is a single construct for both means that the two are effectively the same thing. Combine with this the fact that they can be nested, and you have an extremely versatile construct. I assume this comes directly from the OCaml heritage of F#
- Pattern matching is just awesome.
- Working with Object Oriented concepts is jarring, and feels….awkward. I have no proof, but I can’t help but think this is intentional. While F# is not a “pure” language like Haskell, it still tries to be “functional by default”. The standard types that you work with all the time, like tuples and lists, are immutable, as are the let bindings. You have to be specific if you want the mutable versions of any of these. I can’t help but think the fact that it is easier (or should I say more natural) to work with pure functional types and immutable data structures is a design feature of the language.
The biggest problem I have with F# at this point is that it is clear that it is still a second-class citizen in the VisualStudio world. While it shipped with VS 2010, a lot of the other tooling doesn’t support it. Things like the built in analysis tools, just don’t work. Even the syntax highlighting is less impressive than C#. There is also the fact that there are no built-in refactorings for F#. Event third-party tools like Resharper and CodeRush don’t have support. This is really sad, since the language itself is really a joy to work with. There is still a perception that it is largely academic, and you can’t do any real work in it. This is unfortunate, since in our normal day-to-day programming lives there are some problems that are just functional in nature. In general, functional programing is all about asking questions and getting answers. Contrast this with OO, which stresses a “Tell don’t ask” paradigm. If you divide your application into sections which are suited to “telling” vs “asking” then you may find that you can write certain parts functionally very easily, and others OO equally easy. Wouldn’t it be amazing if people started choosing their languages based on the nature of the problem to be solved, rather than simply because “I’m a C# developer”.