haskell monad for mimicking OO style code - haskell

Question

The concrete examples at http://www.haskell.org/haskellwiki/State_Monad are very helpful in understanding how to write real code with monads (see also stackoverflow/9014218). But most of us new students come from an OO background, so mapping an OO program to haskell will help to demonstrate how to write an equivalent haskell code. (Yes, the two paradigms are entirely different, and it is not wise to translate an OO-style code directly to haskell, but just this once as a tutorial.)
Here is an OO-style code, which creates 2 instances of an object, and then calls member functions which modify their respective member variables, and finally prints them. How do we write this using haskell state monads?
class A:
int p;
bool q;
A() { p=0; q=False;} // constructor
int y() { // member function
if(q) p++; else p--;
return p;
}
bool z() { // member function
q = not q;
return q;
}
main:
// main body - creates instances and calls member funcs
a1 = A; a2 = A; // 2 separate instances of A
int m = a1.y();
m = m + a1.y();
bool n = a2.z();
print m, n, a1.p, a1.q, a2.p, a2.q;

Answer 1

A direct translation would be something like:
module Example where
import Control.Monad.State
data A = A { p :: Int, q :: Bool }
-- constructor
newA :: A
newA = A 0 False
-- member function
y :: State A Int
y = do
b <- getQ
modifyP $ if b then (+1) else (subtract 1)
getP
-- member function
z :: State A Bool
z = do
b <- gets q
modifyQ not
getQ
main :: IO ()
main = do
let (m,a1) = flip runState newA $ do
m <- y
m <- (m +) `fmap` y
return m
let (n,a2) = flip runState newA $ do
n <- z
return n
print (m, n, p a1, q a1, p a2, q a2)
-- general purpose getters and setters
getP :: State A Int
getP = gets p
getQ :: State A Bool
getQ = gets q
putP :: Int -> State A ()
putP = modifyP . const
putQ :: Bool -> State A ()
putQ = modifyQ . const
modifyP :: (Int -> Int) -> State A ()
modifyP f = modify $ \a -> a { p = f (p a) }
modifyQ :: (Bool -> Bool) -> State A ()
modifyQ f = modify $ \a -> a { q = f (q a) }
And I probably wouldn't bother with the manual getter/setters and just use lenses.
{-# LANGUAGE TemplateHaskell, FlexibleContexts #-}
module Main where
import Control.Applicative
import Control.Monad.State
import Data.Lenses
import Data.Lenses.Template
data A = A { p_ :: Int, q_ :: Bool } deriving Show
$( deriveLenses ''A )
-- constructor
newA :: A
newA = A 0 False
-- member function
y :: MonadState A m => m Int
y = do
b <- q get
if b then p $ modify (+1) else p $ modify (subtract 1)
p get
-- member function
z :: MonadState A m => m Bool
z = do
q $ modify not
q get
data Main = Main { a1_ :: A, a2_ :: A, m_ :: Int, n_ :: Bool } deriving Show
$( deriveLenses ''Main )
main :: IO ()
main = do
-- main body - creates instances and calls member funcs
print $ flip execState (Main undefined undefined undefined undefined) $ do
a1 $ put newA ; a2 $ put newA -- 2 separate instances of A
m . put =<< a1 y
m . put =<< (+) <$> m get <*> a1 y
n . put =<< a2 z
But that's not what I'd really write, because I'm bending the Haskell over backward to try and mimic the OO-style. So it just looks awkward.
To me, the real purpose of object oriented code is to program to an interface. When I'm using these kinds of objects, I can rely on them to support these kinds of methods. So, in haskell, I'd do that using a type class:
{-# LANGUAGE TemplateHaskell, FlexibleContexts #-}
module Main where
import Prelude hiding (lookup)
import Control.Applicative
import Control.Monad.State
import Data.Lenses
import Data.Lenses.Template
import Data.Map
class Show a => Example a where
-- constructor
new :: a
-- member function
y :: MonadState a m => m Int
-- member function
z :: MonadState a m => m Bool
data A = A { p_ :: Int, q_ :: Bool } deriving Show
$( deriveLenses ''A )
instance Example A where
new = A 0 False
y = do
b <- q get
if b then p $ modify (+1) else p $ modify (subtract 1)
p get
z = do
q $ modify not
q get
data B = B { v_ :: Int, step :: Map Int Int } deriving Show
$( deriveLenses ''B )
instance Example B where
new = B 10 . fromList $ zip [10,9..1] [9,8..0]
y = v get
z = do
i <- v get
mi <- lookup i `liftM` gets step
case mi of
Nothing -> return False
Just i' -> do
v $ put i'
return True
data Main a = Main { a1_ :: a, a2_ :: a, m_ :: Int, n_ :: Bool } deriving Show
start :: Example a => Main a
start = Main undefined undefined undefined undefined
$( deriveLenses ''Main )
run :: Example a => State (Main a) ()
run = do
-- main body - creates instances and calls member funcs
a1 $ put new ; a2 $ put new -- 2 separate instances of a
m . put =<< a1 y
m . put =<< (+) <$> m get <*> a1 y
n . put =<< a2 z
main :: IO ()
main = do
print $ flip execState (start :: Main A) run
print $ flip execState (start :: Main B) run
So now I can reuse the same run for different types A and B.

Answer 2

The State monad cannot be used to emulate classes. It is used to model state that "sticks" to the code that you're running, and not state that is "independent" and residing in object-oriented classes.
If you don't want method overriding and inheritance, the closest you can get to OOP classes in Haskell is to use records with associated functions. The only difference you have to be aware of in that case is that all "class methods" return new "objects", they don't modify the old "object".
For example:
data A =
A
{ p :: Int
, q :: Bool
}
deriving (Show)
-- Your "A" constructor
newA :: A
newA = A { p = 0, q = False }
-- Your "y" method
y :: A -> (Int, A)
y a =
let newP = if q a then p a + 1 else p a - 1
newA = a { p = newP }
in (newP, newA)
-- Your "z" method
z :: A -> Bool
z = not . q
-- Your "main" procedure
main :: IO ()
main =
print (m', n, p a1'', q a1'', p a2, q a2)
where
a1 = newA
a2 = newA
(m, a1') = y a1
(temp, a1'') = y a1'
m' = m + temp
n = z a2
This program prints:
(-3,True,-2,False,0,False)
Note that we had to create new variables to store the new versions of m and a1 (I just added ' at the end each time). Haskell does not have language-level mutable variables, so you shouldn't try to use the language for that.
It is possible to make mutable variables via the use of IO references.
Note, however, that the following code is considered extremely bad coding style among Haskellers. If I was a teacher and had a student who wrote code like this, I'd not give a passing grade on the assignment; if I employed a Haskell programmer who wrote code like this, I'd consider firing him if he didn't have a VERY good reason for writing code like this.
import Data.IORef -- IO References
data A =
A
{ p :: IORef Int
, q :: IORef Bool
}
newA :: IO A
newA = do
p' <- newIORef 0
q' <- newIORef False
return $ A p' q'
y :: A -> IO Int
y a = do
q' <- readIORef $ q a
if q'
then modifyIORef (p a) (+ 1)
else modifyIORef (p a) (subtract 1)
readIORef $ p a
z :: A -> IO Bool
z = fmap not . readIORef . q
main :: IO ()
main = do
a1 <- newA
a2 <- newA
m <- newIORef =<< y a1
modifyIORef m . (+) =<< y a1
n <- z a2
m' <- readIORef m
pa1 <- readIORef $ p a1
qa1 <- readIORef $ q a1
pa2 <- readIORef $ p a2
qa2 <- readIORef $ q a2
print (m', n, pa1, qa1, pa2, qa2)
This program does the same thing as the above program, but with mutable variables. Again, don't write code like this except for very rare circumstances.