How to avoid OOP deep class hierarchies when switching to Haskell?

Let me first say that I don't know anything about game development, so my answer might well not apply to your question.

That being said, I think the key is to ask the question: why do you use a class hierachy in a language like C++? I think the answer is two-fold: subtype-polymorphism and code reuse.

As you have noted, using inheritance to achieve code-reuse is often criticized, and I believe rightly so. Prefer composition to inheritance is often good advice, it reduces coupling and makes things more explicit. The equivalent in Haskell is just to reuse functions, which is quite simple.

That leaves us with the second benefit: subtype-polymorphism. Haskell does not support subtypes or subtype polymorphsim, but with typeclasses it has another kind of ad-hoc polymorphism which is even more general (in that things don't need to be in a sub-type relationship to implement the same functions).

So my answer is: Think about why you would want a class hierachy. If you want code reuse, then just reuse code by factoring it into sufficiently general functions and reuse these, if you want polymorphism use type classes.

There are some instances where subtyping is actually useful and thus it is sometimes a drawback that Haskell does not support this, but in my experience this is quite rare. On the other hand inheritance tends to be overused in languages such as C++ or Java because that is the one-size-fits-all tool they provide.

In general, I agree with @enoughreptocomment's answer, namely that it is a mistake to reproduce OO designs in Haskell -- you can usually do much better! I was just trying to point out the things that class hierachies give you and how similar things can be achieved in Haskell.

Edit (in response to Zeta's comment):

It's true that typeclasses don't allow heterogeneous types in data types such as lists, however with an extra helper data type this can also be achieved (stolen from the Haskell wikibook):

{-# LANGUAGE ExistentialQuantification #-}

data ShowBox = forall s. Show s => SB s

heteroList :: [ShowBox]
heteroList = [SB (), SB 5, SB True]

instance Show ShowBox where
  show (SB s) = show s

f :: [ShowBox] -> IO ()
f xs = mapM_ print xs

main = f heteroList

Haskell doesn't have subtyping so its going to be hard to directly translate the hierarchy. You can try doing some crazy hack with typeclasses but I wouldn't recommend it, since it gets very complicated very quickly.

The component-based architecture you linked to is just as good for code reuse and is more easily translated into Haskell, since there are no class hierarchies.

For example, in C++ you would have a render component. In C++ you would represent this as an abstract render interface and some concrete Render classes.

class Renderer {
    virtual void draw(double x, double y) = 0;
    virtual void frobnicate(int n) = 0;
};

class HumanRenderer: public Renderer {
  //render Players and Pedestrians...
  //(code reuse!)

  //constructor:
  HumanRenderer(int age);
};

class MedkitRenderer: public Renderer{
  //render the medkit

  //constructor:
  HumanRenderer(Color color);
};

In Haskell, you would do to something similar without subtyping. The type of the parent interface is just a record of functions:

data Renderer = Renderer {
  rendererDraw :: Double -> Double -> IO (),
  rendererFrobnicate :: Int -> IO ()
}

-- I'm putting everything in the IO monad so the code is side effecting like
--in the C++ version. If you want to avoid this mutation then this is where that 
--functional reactive programming stuff would come in.

and the constructors for the concrete classes are just functions that return one of these records.

humanRenderer :: Int -> Renderer
humanRenderer age = -- ...

medkitRenderer :: Color -> Renderer
medkitRenderer rgb = -- ...

Note that since there is a single "Renderer" type, you can put different sorts of renderer in a homogenous list, just like you could in cpp (this would be much trickier to do in the typeclass approach):

renderers :: [Renderer]
renderers = [ humanRenderer 10, humanRenderer 20, medKitRenderer Red ]

The question asks for a Haskell encoding of a class hierarchy with two goals:

1. being able to shove everything into one managing container
2. code reuse

I'll use a smaller variant of the class hierarchy from the question for my examples. The easiest way to achieve goal 1 is to have a single algebra data type for entities. We can then use lists or arrays or whatever container we want that contain entities. So we want:

data Entity = ...
type ExampleContainer = [Entity]

How should we fill in the ...? I first show a naive approach, analyze why it fails to provide reuse, and then turn this insight into a more sophisticated approach that provides reuse.

Naive approach, bad reuse :(

There are multiple kinds of entities in the CEntity class hierarchy, so we could use multiple constructors for the Entity data type:

data Entity
  = Car     Position Velocity Color
  | Player  Position Velocity Gun
  | Door    Position Key
  | Rock    Position

Every leaf of the class hierarchy corresponds to a constructor, but the intermediate classes don't show up. This leads to a duplication in the datatype declaration: We repeat Position and Velocity multiple times. This duplication on the type level also influences the rest of our program: For example, a function that moves objects with a velocity one step forward would look like:

move :: Entity -> Entity
move (Car    position velocity color) = Car  (position + velocity) velocity color
move (Player position velocity gun)   = Tank (position + velocity) velocity gun
move (Door   poosition key)           = Door position key
move (Rock   position)                = Rock position

The duplication of the Position and Velocity fields indeed leads to a duplication of the position + velocity formula. Maybe if we reuse the Position and Velocity fields in the algebraic data type, we can also reuse the position + velocity formula?

Sophisticated approach, better reuse :)

We restructure our algebraic data so that common fields are shared. All entities have a position, but the other fields differ according to what kind of entity we have:

data Entity
  = Entity Position EntityInfo

Moving objects have a velocity but fixed objects don't:

data EntityInfo
  = Moving Velocity Moving
  | Fixed Fixed

A moving object can be a car or a player:

data Moving
  = Car Color
  | Player Name

And a fixed object can be door or a rock:

data Fixed
  = Door Key
  | Rock

So we still have the four constructors Car, Player, Door and Rock, but in addition we have the constructors Entity, Moving and Fixed to store information that is available for multiple kinds of entities. These additional constructors correspond to the intermediate classes in the class hierarchy. Note that we only mention Position and Velocity once, so hopefully the code duplication in the move function should go away. And indeed:

move :: Entity -> Entity
move (Entity position (Moving velocity info))
  = Entity (position + velocity) (Moving velocity info)
move (Entity position (Fixed info)) = Entity position (Fixed info)

Now, the formula position + velocity only appears once, as we hoped.

Summary

One approach for encoding a deep class hierarchy is by algebraic data types. Every class corresponds to a constructor, and every class that has subclasses also corresponds to a data type. If we avoid field duplication in these data type, we also avoid code duplication in the code that manipulates values of the data types.

It is, I think, a rather hard question to answer, because it might be highly dependent on personal coding style. I've switched from large inheritance hierarchies to different designs way before I've written anything in Haskell.

And from my observations, code reuse in Haskell is much simpler than in C++ or Java anyway, because pretty much everything you use, every primitive and element behaves in a predictable, similar way and can be operated on using a small set of very generic functions. That means that as long as you adhere to the rules governing Haskell idiomatic constructs when creating your entities, the fact that the code isn't duplicating should come naturally.

As an example, take a look at fmap. It's an extremely simple, yet an extremely powerful tool. I can imagine you using your player as a Functor and mapping items over him to make them have an effect. You only write the actual effect and and define the player; you don't have to be concerned with how they will have to interact, because there are "standard" ways of doing that.

TL;DR Higher-order functions and typeclasses prove themselves to be really nice when dealing with more complicated logic. Lenses simplify operations on nested data. You have to rethink some things and probably you won't find direct counterparts, but it's certainly possible to write good game code in Haskell.