imperative.hs

import Prelude hiding (tail)
import Data.List (find)
import Control.Monad.State (State,put,get,runState)

type VarName = String
type Variable a = (VarName, a)
type Stack a = [Variable a]

test :: State (Stack String) String
test = do
  set ("name", "Felipe")
  set ("surname", "Miquilini")
  set ("age", "21")
  set ("surname", "C. Miquilini") 
  Just age <- maybeGet "age"
  Just name <- maybeGet "name"
  return $ "I am " ++ age ++ " years old. My name is " ++ name

set :: Variable a -> State (Stack a) ()
set var = do
    xs <- get
    put $ putVar var xs
    return ()

maybeGet :: VarName -> State (Stack a) (Maybe a)
maybeGet varName = do
    xs <- get
    let maybe = find (\(varName',_)->varName==varName') xs
    return $ fmap snd maybe
    
putVar :: Variable a -> [Variable a] -> [Variable a]
putVar var xs = case maybe of Nothing -> var:xs
                              Just var' -> replace (sameName var') xs var
  where maybe = find (sameName var) xs

sameName :: Variable a -> Variable a -> Bool
sameName (varName,_) (varName',_) = varName == varName'

replace :: (a -> Bool) -> [a] -> a -> [a]
replace f xs new = case tail second of Just xs' -> first ++ new : xs'
                                       Nothing  -> xs
  where (first,second) = break f xs

tail :: [a] -> Maybe [a]
tail (_:xs) = Just xs
tail _ = Nothing

Santa Claus gave me my christmas gift. I learned Monads!