10

my question relates to a way how to deal with the inheritance in functional way in F#. To describe it a little, I give a simple example. Suppose we want to model a world consisting of various kinds of animals. Each animal kind shares some attributes with other kinds (e.g. name, size etc.). In addition, each kind may have other, which are not shared by others (e.g. number of children is relevant for dogs and cats, however not for spiders for instance). Also, there might be methods or functions associated with each animal kind which may or may not be same for two animal kinds, i.e. there is default implementation which may be overiden for a particular kind. Each animal kind may have method(s) which is only defined for that kind.

Now, in OOP world, this would probably lead to an abstract class having the common attributes and abstract methods followed by the classes derived for each animal kind. What I am not sure is how to specify the domain model functionally in F#. Here: Which to use , abstract class or interface in F#? is claimed 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".

If this is a the way that should be adopted, would it be possible to provide some elementary example of this?

As for my further thinking on this, I suppose that the attributes should be encapsulated in some structure. Then, most idiomatic structure in this respect in F# is record. Would that mean that there is to be a parent record, which shall be included in other records corresponding to particular "children", i.e. composition instead of inheritance. This however seems to me as a workaround which is neither idiomatic nor particularly elegant.

I think the preferred way how to model inheritance in F# are discriminated unions. However, this does not solve the problem of shared attributes and methods.

The models similar to the one mentioned above, are quite frequent in my view, since are implicitly included in most enterprise applications. Thus, is there any suggestion how this can be handled in functional way (en example to the way suggested under the link above or any other suggestion)? Or shall we say that this is not a domain which can be easily modeled using the functional approach?

Thank you.

Community
  • 1
  • 1
user2039784
  • 199
  • 9

1 Answers1

13

Your description of the example already presupposes the object-oriented programming model. You are describing the problem in object-oriented terms such as overriding and methods defined for certain types of animals. This makes it difficult to give you a sensible alternative functional representation, because your question already assumes object-oriented concepts in the answer.

First, it is perfectly fine to use object-oriented constructs in F# when they make sense (the example in your question is just a toy sample, so this may or may not be the case). The key idea is that F# prefers composition over inheritance and so you would probably try to avoid inheritance (which can lead to complex object hierarchies) and instead compose animals from different aspects.

Second, if you explained your problem in a different way, then there might be perfectly fine functional representation using discriminated unions. For example:

type MammalKind = Cat | Dog
type MammalInfo = { Legs : int; Children : int }

type Animal = 
  | Mammal of MammalKind * MammalInfo
  | Spider of (...)

The idea would be to structure the type so that different kinds of animals (that you can process in a different way) have their own type. For example, you could write a function that takes MammalInfo and performs some computation that only makes sense for dogs and cats (but not for spiders). But as I mentioned earlier, your description of the problem is inherently object-oriented, so it might be difficult to see how this would be done.

Tomas Petricek
  • 240,744
  • 19
  • 378
  • 553
  • Tomas Petricek's answer is a very good one. I would also recommend the following answer by Norman Ramsey: http://stackoverflow.com/a/2079678/631115. – Shredderroy Jun 13 '13 at 20:21
  • Tomas, thank you for the example. It's nice and simple. Regarding the description I gave, I tried to clearly distinct between description and possible implementation (abstract class). I wonder whether the common functions (e.g.function returning name of the animal in some fancy way-for all animals-or some children coefficient-for all mammals) are to be part of the particular types (AnimalInfo-which would be yet created-and MammalInfo) as its members or whether declare them freely (not assigned).I also think that it is a more general question not connected exclusively with the type composition. – user2039784 Jun 14 '13 at 06:21
  • 2
    The key question is extensibility - the functional approach (with free functions) makes it easier to add new operations without changing the type definitions; the OO approach makes it easier to add new derived classes without modifying existing functions (you just implement all virtual methods). In functional style, people generally prefer the ability to add new functions, but if you have a good reason to think that you need the other extensibility, then using interfaces is a good option in F# too. – Tomas Petricek Jun 23 '13 at 20:17