Learning F# - Project Euler #1

I’ve recently decided to start learning F# and my initial thoughts are that to learn the syntax effectively I should stick with writing code (and tests) just for domain logic and not think about IO (connecting to APIs, DBs, etc.)

I decided that something like Project Euler would be appropriate for learning the basic F# syntax. I’ve done some of these ‘code katas’ before but it’s been a good few years.

The first Project Euler is fairly simple and doesn’t require an special mathmatical skills.

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.

My only goal is to write a working solution in order to start learning the F# syntax.

First attempt

I started off with an empty F# project using the XUnit template. - dotnet new xunit --language f#

I them wrote my first function

let multiple5 x = false

Followed by some tests, which will fail to start with, to assert the behaviour of this function.

    [<Fact>]
    let ``Test that multiple of 5 returns true for 5`` () =
        Assert.True(multiple5 5)

    [<Fact>]
    let ``Test that multiple of 5 returns false for 21`` () =
        Assert.False(multiple5 21)

And then updated the multiple5 function to fix the tests:

let multiple5 x = x % 5 = 0

My initial hurdle was understanding the compiliation order is defined with the fsproj file. This was fairly simple however I made it more difficult as I knew I wanted to be able to test this app on the console and therefore ended up with a problem that my test file has to be later in the compilation order, so that it can reference the actual code, however I ended up with the following error:

error FS0433: A function labeled with the 'EntryPointAttribute' attribute must be the last declaration in the last file in the compilation sequence.

The solution to this is to extract the EntryPoint method out into a seperate file that references the Euler1 module. I actually think this is great as it’s forcing the domain logic to be in a seperate library from the console app code.

I continued with creating the complimenting function, multiple3:

let multiple3 x = x % 3 = 0

And then a function which checks whether the parameter is a multiple of either 3 or 5

  let multiple3or5 x =
        multiple3 x || multiple5 x

Then it’s onto iterating over a sequence of numbers and filtering out the numbers which aren’t multiples of 3 or 5.

    let naturalsWhichAreMultiples x = 
        [|1..x-1|]
        |> Array.filter(multiple3or5)

The final piece of the puzzle is the sum of the numbers returned from the above function.

    let sumOfNaturals max =
        naturalsWhichAreMultiples max
        |> Array.sum

To tie everything together and to get the answer for the project euler problem I call this last function from the app Entry Point. Here is the final Program.fs

module Program
    open Euler1
    [<EntryPoint>]
    let main args = 
        let max = args[0] |> int
        let sum = sumOfNaturals max
        printf $"Sum of natural numbers which are multiples of 3 or 5 to %i{max} is %i{sum}"
        0

And the Euler1 module.

module Euler1 
    let multiple3 x = x % 3 = 0
    
    let multiple5 x = x % 5 = 0

    let multiple3or5 x =
        multiple3 x || multiple5 x

    let naturalsWhichAreMultiples x = 
        [|1..x-1|]
        |> Array.filter(multiple3or5)

    let sumOfNaturals max =
        naturalsWhichAreMultiples max
        |> Array.sum

This is a quite length solution to what is a very simple problem, there’s certainly ways to make the code much smaller but this will come with subsequent iterations.

Second attempt

This second attempt is more of a refactor of the first, I’ve basically merged the code from the 5 functions in the above attempt into a single function. It looks a little more cryptic but I think that’s because I’m not used to reading F# code.

module Euler1
    let sumOfNaturals max =
        [1..max-1]
        |> Seq.filter (fun x -> (x % 3 = 0) || (x % 5 = 0) )
        |> Seq.reduce (+)

The final statement could also be replaced with sum…

    let sumOfNaturals max =
        [1..max-1]
        |> Seq.filter (fun x -> (x % 3 = 0) || (x % 5 = 0) )
        |> Seq.sum