Translating object orientated class structure to Haskell

In Haskell, you usually don't model OOP by using typeclasses. Instead, you can just write plain data types that contain functions. In your code, a vehicle is anything that has a go method, which returns a String given a Vehicle. So let's define a datatype that expresses this:

data Vehicle = Vehicle { go :: String }

Now it's very easy to make new vehicles. For example, to convert a Plane to a Vehicle you could write a function plane:

data Plane = Plane { takeoff :: String }

plane :: Plane -> Vehicle
plane p = Vehicle { go = takeoff p }

Or you can make a Car type:

data Car = Car { accelerate :: String }

car :: Car -> Vehicle
car c = Vehicle { go = accelerate c }

If you want, you could even make a ToVehicle typeclass so that you can use the same function to convert Car -> Vehicle as you use to convert Plane -> Vehicle and functions can be generic in which type of Vehicle they accept (without forcing the user to convert to a Vehicle first)

class IsVehicle v where
  toVehicle :: v -> Vehicle
instance IsVehicle Car where
  toVehicle = car
instance IsVehicle Plane where
  toVehicle = plane

But I'd suggest to avoid the typeclass if you can. It's better to rethink your design in this case if you want to do this in Haskell.

This approach isn't exactly OOP because you do not have real subtyping (you cannot pass a Car where a Vehicle was expected, if you don't use the typeclass, so you have to manually convert first), but if you adapt your design to this style I found that is enough in practice. So I'd suggest not to try to translate an OOP-based structure to Haskell, but instead thinking of ways to solve this in the Haskell way.

If you are OK with fixing the types of Vehicles, you can even use Haskell's sum types to express it even simpler:

data Vehicle = Car String | Plane String

This approach is quite different to your original approach, as you don't have separate types here anymore, but maybe it fits your use case if you adopt your architecture a little.

First things first: every language has a different approach at programming. Translating a concept which lies at the core of language X into language Y will often lead to a very poor design. This is because the nice features of Y not present in X are neglected, while trying to put square pegs into round holes.

OOP in Haskell simply does not fit well.

And, for the sake of fairness, many features of Haskell don't fit well in most other languages.

That being said, a common attempt to do some OOP in Haskell is through existential types. E.g.

data Car where
   Car :: state -> (state -> String) -> Car
       -- ^^^^^ the internal representation
                -- ^^^^^^^^^^^^^^^^^ a method

However, in many cases, encoding OOP with existentials is just an anti-pattern. Luke Palmer describes this in a famous blog post. (While I don't fully agree with some points, I find the general argument solid.) For instance, the type above is isomorphic to the simpler type

data Car where
   Car :: String -> Car
       -- ^^^^^^ the method result

and because of laziness, the above works just as well as the original.

Subtyping being non-existent in Haskell, you have to up-cast your types into Car, up-casting meaning converting the "object" into its Car form. Type classes can mitigate this, but often up-casting is not that annoying.

Finally, let me confess I find an OOP a nice but vastly overrated approach to modelling. Just because a few "big" languages are OO-centered, does not mean that OO is the unquestionably best way to model everything.

data Ford = Ford
data Ferrari = Ferrari

class Vehicle v where
    go :: v -> String

class (Vehicle v) => Car v where
    accelerate :: v->String

instance Vehicle Ford where
     go = accelerate

 instance Car Ford where
     accelerate _ = "Vrrom I am ford"

Similarly for plane

class (Vehicle v) => Plane v where
    takeoff :: v-> String

   instance Vehicle Bowing747 where
        go = takeoff

   instance Plane Bowing747 where
      takeoff _ = "taking off from plane"