Haskell中一般函数变换的一个案例

Question

I'm (trying to) learning about mutable state in Haskell. To keep things simple, I define

data Car = Car { position :: Int }

and

move :: Car -> Int -> Car
move c n =  Car { position = n + (position c) }

Thus, move is a "pure" function that represents a transition of a Car into another one.

I think that I'll need to hold a Car in a mutable variable so I can have the current position (after some movements are made to the car). Therefore I define (I hope this is the way to go, otherwise correct me) the following

type Parking = IORef Car -- holds a car

newParking :: Car -> IO Parking
newParking = newIORef 

as well as trivial getCar :: Parking -> IO Car and setCar :: Parking -> Car -> IO () functions.

The above code seems to be fine.

The question:

Could I define a function that transform any pure function like move :: Car -> Int -> Car into a function Parking -> Int -> () that applies move to the parked Car and replaces it with the new one?

The example after incorporating the accepted answer

import Data.IORef
import Control.Concurrent

-- -----------------------------------------------------

timeGoesBy place = do
        moveTheCar place
        threadDelay 1000000
        timeGoesBy place

moveTheCar place = do
     car <- getCar place
     print $ getPos car
     modifyCar place (move 7)    

-- -----------------------------------------------------
main = do
     place <- newParking (newCar 1000)
     timeGoesBy place
     print "end"

-- -----------------------------------------------------

type Parking = IORef Car -- mutable var for holding a car (the car may be replaced)

newParking :: Car -> IO Parking
newParking = newIORef 

getCar :: Parking -> IO Car
getCar = readIORef 

setCar :: Parking -> Car -> IO ()
setCar = writeIORef

modifyCar :: Parking -> (Car -> Car) -> IO ()
modifyCar = modifyIORef

-- -----------------------------------------------------

data Car = Car { position :: Int } -- Car data type ("pure")

-- create a car
newCar :: Int -> Car
newCar v = Car { position = v}

-- get the position of a car
getPos :: Car -> Int
getPos c = (position c)

-- move : transform a given car into a new "moved car"
move :: Int -> Car -> Car -- first the int so that we can curry (i.e. move 7)
move n car = Car { position = n + (position car) }

Answer 1

Alternatively, we could use the State Monad to avoid /actual/ mutability.

import Control.Monad.State

Define the Car stucture

data Car = Car { position :: Int } deriving Show

initiate the state, we use execState, give it a function that will hold the state and the initial state (Car 0).

start :: Car
start = execState myState (Car 0)

move will move your car

move :: Int -> Car -> Car
move n c = c { position = n + position c }

doStuff will help up make it easier to apply functions to the State Monad 'get' gets us the current state (Car 0) and 'put' puts the a new version into the state. We first get it, apply f on it, and then put it in the new state.

doStuff :: MonadState a m => (a -> a) -> m ()
doStuff f = get >>= put . f

This is the State function, here we simply call doStuff with move 1 and it'll modify our car (Car 0) to move 1 Int, so the new result will be Car 1. then we say move 3 and it'll change to Car 4

myState :: State Car ()
myState = do
    doStuff $ move 1
    doStuff $ move 3

With this we can run the start function and receive our modified initial (Car 0).

Answer 2

Yes, you can.

For example:

doCarStuff :: Parking -> (Car -> Car) -> IO ()
doCarStuff = modifyIORef

If you rearrange your move function so that the Car argument comes last, then you can do

doCarStuff myParking (move 5)

which does what you want.

Answer 3

Here's one more possibility, using the lens library to automatically derive "getters" and "setters" for your objects. First there's a little bit of boilerplate

{-# LANGUAGE TemplateHaskell #-}

import Control.Lens
import Control.Monad.State

newtype Car = Car { _position :: Int } deriving (Show)

makeLenses ''Car

Now you can write routines that look and feel 'imperative', for example

program = do
  p <- use position
  liftIO . putStrLn $ "Initial position is: " ++ show p
  position += 3
  q <- use position
  liftIO . putStrLn $ "  Final position is: " ++ show q

main = evalStateT program (Car 0)

which results in

>> main
Initial position is: 0
  Final position is: 3

If you want to use a generic function to modify the fields of a record, you can use over , as in

>> let square x = x * x
>> over position square (Car 4)
Car {_position = 16}

and if you want that to have the same "imperative" feel you had before

action = do
  position %= square
  p <- use position
  liftIO . putStrLn $ "New position: " ++ show p

and

>> evalStateT action (Car 4)
New position: 16