I learned a bit of both Haskell and F#. I love them both but I don't think I am going to get a job with either of them anytime soon! Either way, in my quest for knowledge, there were some features of Haskell I wished were in F#. Of course, I am sure the F# folks have their reasons why things are the way they are. Moving on...

#### [1] Function signature and definition

In Haskell, you can simply write down your function definition and follow that with your implementation as shown in Line 1

` 1: fibonacci :: Int -> Int`

2: fibonacci 0 = 0

3: fibonacci 1 = 1

4: fibonacci n = fibonacci(n-1) + fibonacci(n-2)

In F# however, you cannot add the function definition at the start of the function implementation. Instead, you need to add it to a separate **F# Signature File**. As such the same definition in F# is:

1: let rec fibonacci = function

` 2: | 0 -> 0`

` 3: | 1 -> 1`

` 4: | n -> fibonacci(n-1) + fibonacci(n-2)`

#### [2] Haskell is more explicit about side effects

If you want to deal with Input/Output (IO) in Haskell, you have to be explicit about it. For instance, the definition of the putStrLn function is given as: String -> IO() This clearly states that this function has side effects and it is identified from the get go by the IO parameter. However, in F# you can write a function that has side effects but the function signature may not tell you that.

#### [3] Functions as equations

Looking back at the two fibonacci functions defined both in Haskell and F#, I can say I prefer the Haskell way of doing things. While the F# way is very close, I like the fact that in Haskell I can set up function conditions as a set of equations. You cannot use the same function name more than once in F# as in Haskell.

This was just a short post based on some of my observations. With that said, it's time to get back into the F# game.

## No comments:

Post a Comment