Mutable references to immutable data in Haskell

Question

I'd like to keep track of a "current" value in a succession of immutable values. What is the best way to do that in Haskell without introducing a new reference for every new value? Here is an example:

data Person = Person {name, level, topic :: String }
    deriving(Show)

dierk :: Person
dierk = Person "Dierk" "confident" "Java"

works :: Person -> String
works person = name person ++ " is " ++ level person ++ " in " ++ topic person


main _ = do
    putStrLn $ works dierk
    -- do more with "current" topic
    putStrLn $ works dierk {level= "proficient", topic="Groovy"}
    -- do more with "current" topic
    putStrLn $ works dierk {level= "dabbling", topic="Haskell"}
    -- do more with "current" topic

It depends. Mutability can be obtained through the `State Person` monad. If you also need to do IO on top of that, then you probably need `StateT Person IO` instead. — chi, Mar 14 '15 at 20:56
The State monad doesn't cut it since you only get state succession (new states with every change) but no reference to a "current" state. — Dierk, Mar 14 '15 at 21:03
It's very unclear to me what you are trying to express in this bit of pseudocode. — dfeuer, Mar 14 '15 at 21:09
What would you consider a "reference to a current state", exactly? It can't be some value `current :: Person` since that would be immutable. — chi, Mar 14 '15 at 21:09
It is most likely is some kind of reference type but IO should not be required. — Dierk, Mar 14 '15 at 21:16

score 3 · Accepted Answer · answered Mar 14 '15 at 21:26

I'm not sure about what the question really asks for. The posted example can be rewritten to use the StateT Person IO monad as follows.

import Control.Monad.State

data Person = Person {name, level, topic :: String }
   deriving Show

dierk :: Person
dierk = Person "Dierk" "confident" "Java"

works :: Person -> String
works person = name person ++ " is " ++ level person ++ " in " ++ topic person

main :: IO ()
main = flip evalStateT dierk $ do
   -- use the current topic
   lift . putStrLn . works =<< get
   -- change the current topic
   modify (\t -> t{level= "proficient", topic="Groovy"})
   lift . putStrLn . works =<< get
   -- change the current topic
   modify (\t -> t{level= "dabbling", topic="Haskell"})
   lift . putStrLn . works =<< get

{- Output:
Dierk is confident in Java
Dierk is proficient in Groovy
Dierk is dabbling in Haskell
-}

If instead a real reference type is wanted, one could use IORef Person, or STRef if in the ST monad. But in such case, you must be working inside some monad allowing these reference types. By comparison, StateT Person m works in any monad m.

Thanks, this is certainly a solution for my question. – Dierk Mar 14 '15 at 21:51 — Dierk, Mar 14 '15 at 21:51

score 0 · Answer 2 · answered Mar 15 '15 at 19:49

Just to wrap up and give hints to other Haskell newbies like me - here is the solution that I finally settled with. This is no pseudo-code :-) but Frege (a Haskell for the JVM) that has some minor notational differences.

module Person where

import frege.control.monad.State

data Person = Person {name, level, topic :: String }

derive Show Person

dierk = Person "Dierk" "confident" "Java"

works :: Person -> String
works person = person.name ++ " is " ++ person.level ++ " in " ++ person.topic

printCurrentPerson :: StateT Person IO ()
printCurrentPerson = do
    person <- StateT.get            -- independent of any particular person reference
    StateT.lift $ println $ works person

updateCurrentPerson :: Monad m => String -> String -> StateT Person m ()
updateCurrentPerson level topic = do
    StateT.modify (\person -> Person.{level= level, topic=topic} person)

usingMutableRefsToImmutableState :: Person -> IO ((),Person)
usingMutableRefsToImmutableState start =
    flip StateT.run start $ do
        printCurrentPerson
        updateCurrentPerson "proficient" "Groovy"
        printCurrentPerson
        StateT.lift $ println "-- user input could influence which selection is 'current' "
        updateCurrentPerson "dabbling" "Haskell"
        printCurrentPerson

main = do -- using the StateT transformer to work in combination with any monad (here: IO)
    (_, lastPerson) <- usingMutableRefsToImmutableState dierk
    println "-- a second round with relaying the last person"
    _ <- usingMutableRefsToImmutableState lastPerson
    return ()

{-  output
    Dierk is confident in Java
    Dierk is proficient in Groovy
    -- user input could influence which selection is 'current' 
    Dierk is dabbling in Haskell
    -- a second round with relaying the last person
    Dierk is dabbling in Haskell
    Dierk is proficient in Groovy
    -- user input could influence which selection is 'current' 
    Dierk is dabbling in Haskell
-}

Thank you all.

Mutable references to immutable data in Haskell

2 Answers2