Making Haskell Monads

Question

I'm trying to create a very simple monad in Haskell. The monad does nothing special but holding a counter as state.

module EmptyMonad
  ( EmptyMonad
  ) where

import Control.Monad

data EmptyMonad a = EmptyMonad
  { myValue :: a
  , myState :: Int
  } deriving (Show)

instance (Eq a) => Eq (EmptyMonad a) where
  EmptyMonad x1 y1 == EmptyMonad x2 y2 = x1 == x2 && y1 == y2


instance Monad (EmptyMonad a) where
  return x = EmptyMonad x 0
  (EmptyMonad x y) >>= f = EmptyMonad x (y + 1)

After spending few hours on Monads, I cannot get my head around the error from the compiler:

EmptyMonad.hs:16:10: error:
    • Expecting one fewer argument to ‘Monad EmptyMonad’
      Expected kind ‘k0 -> Constraint’,
        but ‘Monad EmptyMonad’ has kind ‘Constraint’
    • In the instance declaration for ‘Monad EmptyMonad a’
Failed, modules loaded: none.

You should write instance Monad EmptyMonad where (without a). — Willem Van Onsem
Furthermore it should be (EmptyMonad x y) >>= f = EmptyMonad (f x) (y + 1). (with f), otherwise the types do not match. — Willem Van Onsem
I would advise you to read Kinds and some type-foo and Making monads — Redu
As a complete aside to your problems understanding and using Haskell syntax, you are also going to have a semantic problem. Counting binds is not okay in monads; it violates the "return is an identity" law saying that return x >>= f = f x, since there are fewer binds on the right-hand side of the equation. (It seems to be everybody's first idea for a new monad, though, including mine!) — Daniel Wagner

Willem Van Onsem Willem Van Onsem · Accepted Answer · 2017-10-03T18:11:48

There are two main problems here:

the instance declaration does expect a type of kind * -> *. So for instance [], not [a]; and
the bind operator >>= expect an EmptyMonad a, and a function a -> EmptyMonad b and returns an EmptyMonad b element.

So we can fix the problems with the following solution:

instance Monad EmptyMonad where  -- no a after EmptyMonad
  return x = EmptyMonad x 0
  (EmptyMonad x y) >>= f = fx {myState = y+1}
      where fx = f x

So here we specify instance Monad EmptyMonad since EmptyMonad has kind * -> *. Furthermore the bind operator will calculate f x and then alter the myState of that instance with y+1.

That being said, nowadays you need to make EmptyMonad an instance of Applicative and Functor as well.

Making Haskell Monads

1 Answers