Question

Been grokking F# coming from a C# background.

In C# there is a clear difference in deciding when to use interfaces and when to use abstract classes. In F# I see the two blurring almost into one. I understand under the hood that the same is being done in F# as c# as far as the CLR is concerned, but what is the “best practise” when programming in F# to use?

Should I avoid class inheritance altogether?

Answer 1

I think that interfaces tend to be used much more frequently than abstract classes (compared to object-oriented languages like C#).

In many cases, you don’t need any of the two, because you can just write higher-order function (that takes a function as an argument, instead of taking an interface as an argument). However, sometimes you may have two functions that are always used together – in that case, you can group two functions into an interface:

// Instead of using higher-order function
val foo : (int -> string) -> (string -> int) -> ...

// ..we can define an interface
type TwoWayConversion = 
  abstract ToString : int -> string
  abstract FromString : string -> int

val foo : TwoWayConversion -> ...

I think that this is quite useful F# programming pattern that uses interfaces in a perfectly functional style.

On the other hand, I would use abstract classes only when writing object-oriented code that is supposed to be used from C# (e.g. C# code implementing your F# abstract class) – because that’s a natural extensibility point from the C# point of view. However, I think that idiomatic F# code uses different extensibility points than C# (e.g. taking function/interface as an argument), so you don’t really need abstract classes.