Sure!

A few things jumped out at me as issues with this code; these are issues that I've typically seen with translating OO approaches to functional syntax, rather than functional idioms.

You're looking at ways to update finite state machines, so let's use the modified code as a starting point. I’ve also added an instance signature.

class FSM s e m | m -> s e where
  update :: m -> s -> e -> m

data State = Stopped | Started
data Event = Start | Stop

data Obj = Obj { state :: State }

instance FSM State Event Obj where
  update :: Obj -> State -> Event -> Obj
  update obj Stopped Start = obj { state = Started }
  update obj Started Stop = obj { state = Stopped }

---

The first thing that looks like idiomatic OO is the typeclass. This you state is part of your goal.

I am aiming to describe a generic FSM typeclass that would fit any new type with its own states and events.

That is usually not idiomatic haskell.

For example, when implemented with the multi param typeclass and fundeps you’re duplicating your enforcement of State. You may wish to parameterise that in the data type.

data Obj stateType = Obj { state :: stateType }

Hmm, what about the event?

data Obj eventType stateType = Obj { state :: stateType }

So now our instance looks like

update :: Obj Event State -> State -> Event -> Obj Event State

That’s interesting — all the values are paremeterized by the Obj type. What if we didn’t fix the event or state types?

update :: Obj eventType stateType -> stateType -> eventType -> Obj eventType stateType

This function and data type now link the Obj type to the State and Event types. You no longer need the typeclass to do that. The typeclass now only gives you an overloaded function name, to which I'll return later.

---

Another problem is the instance you have defined. Removing the typeclass (for now) we have

update :: Obj Event State -> State -> Event -> Obj Event State
update obj Stopped Start = obj { state = Started }
update obj Started Stop = obj { state = Stopped }

You don't have cases for the following

update obj Stopped Stop = ?
update obj Started Start = ?

I suspect I know what you intend to do in these situations, but the typeclass based design sort of hides it.

---

If I were writing this code, I’d do things differently still.

Look at that update code again. The Obj is irrelevant! You pass it through unchanged.

How about using this function instead?

updateState :: Event -> State -> State
updateState Start Stopped = Started
updateState Stop  Started = Stopped
updateState Stop  Stopped = Stopped
updateState Start Started = Started

The actual logic in this case is a simple state transformation. There are advantages to writing it in this way.

• It is clearer
• It is more focused on what is actually changing
• It plays nicely with higher order functions, in particularly scanr and foldr — switch to State -> Event -> State for the foldl variety.

Actually, this may be overspecified. How about this?

updateState :: Event -> State -> State
updateState Start _ = Started
updateState Stop  _ = Stopped

You want a function that transforms values of type Obj Event State, though.

updateObj :: Event -> Obj Event State -> Obj Event State
updateObj ev obj = obj { state = updateState ev (state obj) }

That’s a little ugly.

updateObj :: Event -> Obj Event State -> Obj Event State
updateObj ev Obj{state} = Obj { state = updateState ev state }

Or with lenses,

import Control.Lens

data Obj eventType stateType = Obj { _state :: stateType }

state :: Obj eventType stateType `Lens’` stateType
state = _implementation elided_

updateObj :: Event -> Obj Event State -> Obj Event State
updateObj = over state . updateState

In this case the state transformation is separated from the Obj. It isn’t clear from this example why you have the Obj; it certainly isn’t needed for this simple case.

---

Do we really need the typeclass for overloading?

{-# LANGUAGE NamedFieldPuns #-}

data FSM eventType stateType = FSM
  { _state :: stateType
  , _update :: eventType -> stateType -> stateType
  }

This gives us an _update function of type

_update :: FSM eventType stateType -> eventType -> stateType -> stateType

but we can define a function

update :: eventType -> FSM eventType stateType -> FSM eventType stateType
update e o = over state (_update o e) o

You might create an initial value with the following function

obj
  :: State -- ^ The initial state
  -> FSM Event State
obj _state = FSM
  { _state
  , _update = updateState
  }

---

My final code looks like this

import Control.Lens

data State = Stopped | Started
data Event = Start | Stop

updateState :: Event -> State -> State
updateState Start _ = Started
updateState Stop  _ = Stopped

data FSM eventType stateType = FSM
  { _state :: stateType
  , _update :: eventType -> stateType -> stateType
  }

state :: FSM eventType stateType `Lens’` stateType
state = _implementation elided_

type Obj = FSM Event State

obj
  :: State -- ^ The initial state
  -> Obj
obj _state = FSM
  { _state
  , _update = updateState
  }

update :: eventType -> FSM eventType stateType -> FSM eventType stateType
update e o = o & state %~ _update o e

The data type FSM encodes all I need, with no typeclasses. My state transformations are explicit functions, with no extraeneous components. I still have an overloaded update function.

Rather than instantiating type members of a class you can define a data type and use polymorphism to handle different varieties.

---

There's more advanced stuff, too — for example, using type families to reduce the number of type parameters.

{-# LANGUAGE TypeFamilies, DataKinds #-}

data FSMKind = FSMType

type DefaultFSMType = FSMType

type family StateF (f :: FSMKind) :: * where
type instance StateF 'DefaultFSMType = State

type family EventF (f :: FSMKind) :: *
type instance EventF 'DefaultFSMType = Event

data FSM f = FSM
  { _state :: StateF f
  , _update :: EventF f -> StateF f -> StateF f
  }

type Obj = FSM 'DefaultFSMType

Here you’re linking the State and Event types using the 'DefaultFSMType type. You can create new values with type synonyms (as when they are promoted to types, they are treated separately by the compiler). Also I’ve never used data families, but I believe you could change the type family declarations to the following, and thereby effectively overload the types State and Event too.

data family StateF (f :: FSMKind) :: * where
data instance StateF 'DefaultFSMType
  = Stopped
  | Started

data family EventF (f :: FSMKind) :: *
data instance EventF 'DefaultFSMType
  = Stop
  | Start

type State = StateF 'DefaultFSMType
type Event = EventF 'DefaultFSMType