Thanks for your response. There 's one thing I don't understand however: the countRef function returns the same MVar all the time. What 's the reason for that ? I would expect that every time that function is invoked, it returns a new MVar, but clearly it does not. From the documentation of unsafePerformIO Use {-# NOINLINE foo #-} as a pragma on any function foo that calls unsafePerformIO. If the call is inlined, the I/O may be performed more than once. I try to conclude that writing the Pragma NOINLINE somehow makes sure that the result of countRef is computed only once! And subsequent invocations of the function will return the same result. In a way this makes sense because a function that is invoked twice with the same arguments "computes" the same result. But, somehow it is a very nasty hack. Am I getting it, or am I completly wrong ? kind regards, Pieter On 18-feb-07, at 03:26, Donald Bruce Stewart wrote:

pieter:

...

Hello,

I'm trying to write a simple module for the haskell web server (hws- cgi).

And I would like to write a simple module that maintains some kind of state for a session.

But I'm I write I cannot do this in pure Haskell ? Without adopting the sources of the Haskell web server ?

I'll examplify to make it more concrete :

The requestHandler function a module has to implement has this signature.

requestHandler :: ServerState -> ServerRequest -> IO (Maybe Response)

Let 's assume I have this implementation

requestHandler st _ = return $ Just $ mkRequest where mkRequest = okResponse (serverConfig st) mkBody hs True mkBody = HereItIs " This is a test" hs = mkHeaders [contentTypeHeader "text/html"]

And I would like the response to include, for example, a number indicating the number of calls that has been handled by the module.

I would concider using an Mvar but I can't "remember" the mvar between requests.

Am I right to assume that the interface of the requestHandler method has to be adapted ? Or that serverstate has to be adopted so that it can act as a datastore ?

I don't think so.

You could, for example store the count on disk, and read it back in. Or you could simulate a disk store by using a mutable variable, hidden in your module:

module M (requestHandler) where

import Control.Concurrent.MVar import System.IO.Unsafe

-- -- A threadsafe mutable variable, internal to this module. Rather -- than use, say, a disk file as storage, we can keep the count here. -- countRef :: MVar Int countRef = unsafePerformIO $ newMVar 0 {-# NOINLINE countRef #-}

---------------------------------------------------------------------- -- -- And a quick example:

type Response = Int

requestHandler :: IO (Maybe Response) requestHandler = do n <- modifyMVar countRef $ \c -> return (c+1, c) print $ "received " ++ show n ++ " requests." return $ case n of 0 -> Nothing _ -> Just n

*Main> requestHandler "received 0 requests." Nothing

*Main> requestHandler "received 1 requests." Just 1

*Main> requestHandler "received 2 requests." Just 2

*Main> requestHandler "received 3 requests." Just 3

This seems simpler than writing the count to disk. And as long as you stay in IO, perfectly safe.

In the longer term, you might want to look at state-parameterised plugins for the HWS. We do this in lambdabot, associating a private state type with each plugin, which is managed by the main server. The plugins can then get or set internal state, without resorting to local mutable variables.

-- Don