Let’s begin with the spoilers, we are going to do this :-P

Yep, the bulk of the job will be done by seven lines of code, but let’s go tiny step by tiny step. To perform this feat we are going to use two different type providers:

1. CSV Type Provider, which reads a sample .CSV file, creating classes that represent a row and its columns, and functions that load files with similar structure returning a collection of well-typed objects.
2. SQLProvider, which let us work against a relational database as illustrated in this previous post.

To begin with we have to create a folder, then a project inside it, and get these three packages: SQLProvider, MySQLData, and FSharp.Data. You can find detailed instructions on how to do this in steps 1 to 3 of this post (if you haven’t done it yet, this is a good time to follow that step-by-step guide). You should end up with a structure similar to this one:

Let me explain the “nice trick”: sometimes Paket, our package manager, is too eager, downloading library flavors for (too) many .NET Framework versions, line 1 framework: auto-detect in the paket.dependencies file, forces Paket to restrict itself to the framework versions actually present in my machine, so this is an optional step that, at least in my case, saves downloading a bunch of extra files.

Now back to our job, and there is one last configuration task to do before getting into the coding fun: as we are going to create a stand-alone executable, we need to be able to compile the project -in previous posts I have only used .fsx script files-, to accomplish this we will use Fake, a project builder á la C make, only functional and written in F# of course. Fake relies on the .fsproj project file to guide its work so we need to add the appropriate libraries to it, in order to do so:

1. Press Ctrl-Shift-P, enter F#, and choose the F#: Add Reference option
2. Select LoadCsv.fsproj from the list (or whatever the name of your project is)
3. Enter FSharp.Data
4. Repeat the same steps but now enter SQLProvider

If you want, just as a sanity check, you can open the LoadCsv.fsproj file and somewhere close to the bottom you should see references to the libraries, something like the image below, if they’re there, we’re good, smile, close it, and forget about it :-)

Now, onto data folders and files, as we said when we first mentioned the CSV Type Provider, it needs a sample .CSV file, so we create a data folder inside the LoadCsv folder, and there we create the paymentsSample.csv file (by the way, you can find the files related to this blog post here).

And we are finally ready to code! When we created the LoadCsv project, a LoadCsv.fs file was also created, this is our main (and only :-) ) source code file, it’ll be just a few lines long, and the gist of it is:

As I mentioned before, you can find the source code here, but I really suggest you to type in the code yourself in order to get a feeling for the language and the environment. Some relevant comments:

1. Lines 7 to 9 just initialize some constants for the SQL provider, of particular note is ResPath, the path to the folder containing the MySQL assembly.
2. Lines 11 and 12 create the type providers, here’s where the magic happens. Payments will know all about the .csv file contents, DbProvider will know all about the sales database.
3. The loadCsv function does all the hard work: line 16 reads the whole .csv file found at path, so that payments is bound to a collection of objects with four properties (Id, Name, Amount, Date) each, context is our gateway to the sales database.
4. At line 18 we take the lines already read from the .csv file and let the iter() function process each one with a lambda (OK, OK, just a function with no name :-) ), where p is already an object with properties for every field in the line
5. At line 20 we create a new database row with the funnily named function ``Create(Amount, Date, Name)`` (yep, that’s its name, automatically created by the SQL provider), in line 21 we also set the primary key, that unfortunately is not a parameter for the Create() function :-( so we have to do it by hand, and in a mutable way also -a sin in the functional world but that’s what happens when you mess with external repositories. Mind you: the new row has not been committed to the database yet.
6. Finally in line 22 we submit all the new rows to the database in one big transaction.

Just not to be too lame, we surround everything with some very basic exception control, and that’s pretty much it, 15 lines of code for the whole thing is not that bad, right? Let’s run it!

Beware of micro-benchmarks, but still: eight something seconds to load 10,000 records to a table is not bad, especially in my so-so laptop :-)

I know this has already become a long post, but one last thing may be bugging some of you: what if the .csv file had one million lines? Do we really want a one-million-inserts transaction at line 22? May be a small enhancement is in order:

Just two small changes:

1. At line 19 we use the iteri() functions which gives us an additional parameter: a counter of how many lines have been processed already
2. Then at line 22 we submit the new rows every 500 lines, a far shorter database transaction

And that’s it, I hope this gave you an idea of how much you can achieve with just a few lines of F#, as usual all feedback is welcomed!

1. An F# development environment similar to the one we set up here: Mono runtime, F# 4.1 compiler, and VS Code with Ionide extensions.
2. Also you need the MariaDB engine installed and working, with its usual test database.

Once you are past this, we can start our step-by-step:

First: Open a terminal, create a folder, get into it, and start VS Code with a code . command.

Second: Once VS Code is started up, press Ctrl-Shift-P to open the command bar, type F# and then select the F#: New Project option.

In the option bar that appears at the top select the console Console Application option, then press Enter to use the current folder as the parent for the project we are creating, and finally type helloDB as the name of our brand new F# project.

If everything went fine, a confirmation will be displayed and an initial structure with three folders and a couple of files will be shown, like so:

Third: Now we are going to download the two packages that we need to work with MariaDB (or MySQL) from F#:

1. Press Ctrl-Shift-P to open the command bar and then type Paket, select the Paket: Add Nuget Package option, and in the text box that appears at the top enter SqlProvider, this is the F# type provider for working with several relational databases (more information here).

2. For the second library, press Ctrl-Shift-P again, type Paket, select the Paket: Add Nuget Package option, and in the text box enter MySql.Data. This is the .NET library for working with a MySQL (or MariaDB) database engine.

As a sanity check, open the paket.dependencies file by clicking on it, the file should contain these two lines (the order or exact location isn’t important):

Fourth: Now we are finally ready to enter some F# code, let’s create a script file so we can work line by line: right-click on the helloDB folder and choose the New File option from the pop-up menu, then type learning.fsx as the name of the new script file.

Fifth: Create a SQL data provider by typing these 6 lines of code:

Some relevant comments:

1. The first line instructs the F# environment to go ahead and load that assembly, so that we can use the functions defined in it in our code, as usual in Linux be careful with the casing
2. The open at line 3 is similar to a C# using or a Java import
3. The Literal attribute makes ConnString and friends string constants available at compile time (far before runtime), this is a requisite for the type provider to do its magic while we type code
4. Line 12 is the kicker, risky and magical stuff happens as soon as you hit Enter at the end of that line:
   a) The F# environment tries to connect immediately to the test database, if the DB server or the database is not available, or the credentials are wrong, a compilation error is fired, this is the risky part
   b) If the connection goes well, SQLDataProvider is ready to explore the database structure and generate on the fly, as we keep entering code, classes that represent tables, rows, columns, etc. This is the magical part
5. A keen eye would observe that while in line 1 the path ../packages/…starts with two dots, in line 9 the path ./packages/… starts with just one dot. This is indeed an inconsistency, I ignore if it’s caused by the VS Code extensions, a bug in SQLDataProvider, or something else, but at least we have a workaround that works consistently :-)

Sixth: Now the real fun begins, we define a context object that is our gateway to the database, through it we can navigate the database with Intellisense and all, even to the point of primary keys!

Seventh: Now I am pushing into information that is really better explained at the SQLProvider site, but just to be a little complete we can create a new row and save it to the DB table:

As I said at the beginning of the article: this was a step-by-step guide with a really simple escenario, the goal being setting up your Linux F# environment so that you can start using the SQL type provider for some real work. Come to think of it, may be a future post with examples showing some fancy queries, joins and the like, is in order B-)

Someone may say that longitude and latitude should have getters, but since a Position instance doesn’t change (hence the final in the field declarations), defining and using a getter seems excessive and I don’t want to make Java look longer than necessary. Now the F # version:

The enum syntax is different, but the equivalence is clear. Position does bring some new ideas: what we are seeing is a record declaration, a simple object type that only has properties, which are also immutable (like Java’s final fields), this could look like a very narrow case, but as F# favors using immutable elements, it happens much more frequently than in your average O-O code.

Now on for something with more meat to it -with apologies to my vegan friends :-) The Vehicle class, which is abstract, has a few fields, a constructor and a method. The Java version:

As is usually the case, the Color, Position, and Speed fields, together with its getter and setter declarations take up much of the space; the constructor initializes a couple of those fields via its respective setters, as recommended in Java; finally, the Accelerate method increases the speed and returns the new value, of course we could, we should, have much more logic there but that’s not the focus of this article. Now the F# version:

Right at the first line, it is kind of odd the usage of the AbstractClass attribute to signal that we are dealing with an abstract class (hey! No one said everything was going to be obvious around here :-) ), with that over let’s deal with more salient details:

1. The parentheses just after the class name indicate that the default constructor has no arguments (aha, yes, those “()” are our Vehicle() constructor declaration ;-))
2. Color, Position, and Speed are properties with invisible fields behind them, with automatically generated getters and setters, similar to those of the Java version
3. That {length = 0.0; latitude = 0.0} code instantiates a Position object, in effect it is the equivalent of new Position (0, 0)
4. The Accelerate method has one argument, no parentheses around it needed, no return keyword required either: the very last evaluated expression, in this case this.Speed, is returned
5. Finally, there’s no need for any type declaration, all those Color, Position, float-> float, and the like in light grey, are visual hints created by the compiler, nothing that I had to type in.

All in all, we’re talking about 32 Java lines vs. 8 F# lines to express the exact same thing. A 75% savings of lines to read and understand is pretty good, isn’t it? :-)

We are almost done, Car is a class inherited from Vehicle that adds a field, immutable just to illustrate the way such thing are done, and a method. The Java version:

Brand is a property initialized inside the constructor that doesn’t change afterwards; the constructor receives two parameters: brand which is mapped to a local field and color which is mapped to an ancestor field via its setter; Finally, the PullHandBrake method slows down the car to 0 (I did say that this was going to be a simplistic example, right? :-)) using the ancestor’s methods and getters, nothing earth-shattering here. Now, the F # version:

Car descends from Vehicle, the syntax is obvious, but again we have some interesting details:

1. The () after Vehicle signal which ancestor constructor will be called as part of a Car object instantiation, so it causes the same effect as a Java super() call
2. The Car constructor itself takes two parameters, which are used in two different places: a) Inside the do statement, where the default constructor logic is placed; b) At the Brand property initialization Brand: string = brand, which by the way has no setter, making it immutable.
3. The value returned by PullHandBrake is the same as in Java, but I like to think that there is less noise here :-)

Here we had only a 50% savings in code lines but still not that bad, eh?

I hope that these (very) simple examples made it clear that F# can be as O-O as Java or C#, but remember: it is a good idea to try to be functional first and only when it doesn’t come natural to go back to O-O, otherwise what would have been the point of moving to a functional language? Any comments?

Update 1: You can get the F# and Java code samples here.

Update 2: Join the functional movement!

Download | Mono

Second: Install F#, this step first installs Mono and then F# proper, so it takes a few minutes, have a little patience :-)

Use F# on Linux | The F# Software Foundation

You could start writing F# code already albeit using the command-line tools so…

Third: Install Visual Studio Code, a developer’s open source editor, you download a .deb package, and then double-click it.

Visual Studio Code - The open source AI code editor

Fourth (and last): Launch Visual Studio Code (writing code at a command line will do), then install the ionide plug-ins: F#, Fake (a build utility, like C make, but written in F# itself), and Paket (a packet manager, like maven, npm, or nuget, equally written in F#).

And you’re all set! You can now experience coding in a functional language on a lightweight open source environment :-)

Join the functional movement!