You're on the right track, and yes you can do what you want to do. I'll explain by rewriting some of your code to use the state monad. {-# LANGUAGE GeneralizedNewtypeDeriving #-} import Data.Binary import Control.Monad.State as S import IO import qualified Data.ByteString as BS import Data.Bits (shiftL) import Data.Char (chr) newtype MyMonad a = MyMonad (StateT Handle IO a) deriving (Functor, Monad, MonadState Handle, MonadIO) runMyMonad :: MyMonad b -> Handle -> IO b runMyMonad (MyMonad proc) = fmap fst . runStateT proc What the above code does, is sets up a state, which in this case just holds a handle (but it could have been any user defined state). It uses ghc's newtype deriving extension to get the common instances that you'll need. This is generally way easier than writing the instances yourself. It wraps it in a newtype which you can call whatever you want to make things simpler when you are thinking about the types involved. For the rest of the code I'm just going to rewrite your code with "'"'s behind them to denote that they are changed. streamInt' len = S.get >>= \h -> liftIO $ liftM bsVal $ BS.hGet h len hGet' len = S.get >>= \h -> liftIO $ BS.hGet h len getNTS' = S.get >>= liftIO . getNTS -- basically just your functions with a liftIO in front, and a call to get to get the handle from your state monad. getHIP' :: Handle -> IO PktHIP getHIP' = runMyMonad getHIP'' where getHIP'' :: MyMonad PktHIP getHIP'' = do ver <- streamInt' 1 str <- getNTS' tid <- streamInt' 4 buf <- hGet' 8 hGet' 1 -- filler scap1 <- streamInt' 2 slang <- streamInt' 1 sstat <- streamInt' 2 scap2 <- streamInt' 2 scrln <- streamInt' 1 hGet' 10 -- filler scram <- getNTS' return $ PktHIP { hipProtoVer = ver , hipSvrVer = str , hipThreadId = tid , hipScramble = buf , hipSvrCaps = fromIntegral scap1 -- scap2 << 2 ? TODO! , hipSvrLang = slang , hipSvrStat = sstat , hipScramLen = scrln , hipPlugin = scram } This function is the same as yours, except that it doesn't need to worry about handles. And right about this point you are saying, wait a second this code is still long. If you were using more than just a single handle, you could fit a lot more in that state. There's another thing you can do that I'm aware of to squeeze a little more brevity out of your code. That is called applicatives. Instead of writing getHIP in monadic style, you can do it in applicative. Well actually you can almost do it in applicative style, because your structure does not quite match up with the data you are retrieving. It would look something like this (untested): import Control.Applicative getHIP h = PktHIP <$> streamInt h 1 <*> getNTS h <*> streamInt h 4 <*> ... etc ... <*> getNTS h <$> is just another word for fmap. If the types of your records match up (or you can coerce them ie for hipSvrCaps would be "<*> (fromIntegral <$> streamInt h 2) <*>" you can put it all in one big line or two. If you have any other questions, let me know. On Tue, Apr 3, 2012 at 6:26 PM, Sean Charles wrote:

Hi list,

to further my haskell skills I decided to produce my own raw MySQL connection. So far I can connect to the server and extract the handshake initialisation packet (HIP) and create the client authentication packet. Once I've figured out how to implement the salting and hashing I have a chance of starting a session. Not a problem, just got to do it. I want a module that I can use for simple DBMS I/O that doesn't use libmysql or odbc as sometimes these things just refuse to install on certain platform / architecture combinations!

So, here's my problem: I kind of understand monads, I can use them and appreciate what/why they are useful etc. but my current implementation of reading the HIP into the type I created (shown next) appears to me at least to be plain clunky, ugly and inelegant compared to ninja haskell code I've read and one day hope to match, here's my code... apologies for the length of the post but I hope it's interesting to some!

data PktHIP = PktHIP              { hipProtoVer :: Int              , hipSvrVer   :: String              , hipThreadId :: Int              , hipScramble :: BS.ByteString              , hipSvrCaps  :: Integer              , hipSvrLang  :: Int              , hipSvrStat  :: Int              , hipScramLen :: Int              , hipPlugin   :: String              } deriving(Show)

and reading it...

getHIP :: Handle -> IO PktHIP getHIP h = do  ver <- streamInt h 1  str <- getNTS h  tid <- streamInt h 4  buf <- BS.hGet h 8  BS.hGet h 1 -- filler  scap1 <- streamInt h 2  slang <- streamInt h 1  sstat <- streamInt h 2  scap2 <- streamInt h 2  scrln <- streamInt h 1  BS.hGet h 10 -- filler  scram <- getNTS h  -- todo: there *has* to be a more concise way of doing this?  return $    PktHIP { hipProtoVer = ver           , hipSvrVer   = str           , hipThreadId = tid           , hipScramble = buf           , hipSvrCaps  = fromIntegral scap1 -- scap2 << 2 ? TODO!           , hipSvrLang  = slang           , hipSvrStat  = sstat           , hipScramLen = scrln           , hipPlugin   = scram           }

-- Extract an N byte Int value from the input stream streamInt :: Handle -> Int -> IO Int streamInt h len = liftM bsVal $ BS.hGet h len

bsVal :: BS.ByteString -> Int bsVal = BS.foldr' (\byte total ->  fromEnum byte + (shiftL total 8)) 0

-- Get a Null-Terminated String getNTS :: Handle -> IO String getNTS h = streamInt h 1 >>= \b -> getString h "" b           where             getString :: Handle -> String -> Int -> IO String             getString h acc c               | c == 0  = return $ reverse acc               | otherwise = streamInt h 1 >>= getString h ((chr c):acc)

Then I read about the Data.Binary package and the Get monad and got this far...

readHIP :: Get (Maybe PktHIP) readHIP = do  return (Nothing)

I looked at the example on this page: http://www.haskell.org/haskellwiki/DealingWithBinaryData , I stopped because I realised that the Get monad was only going to mean I ended up with very similarly structured code and probably  a lot of it. I know the PktHIP has lots of fields but even so I am convinced it can be reduced and re-factored into much more beautiful code that I know how to write so far.

I've tried to reason about it and I can "see" that there is a function out there that takes a Handle and "a record modifier function" and I can see also that it might be time for me to create my first Monad type ever IIUC, by implementing >>=, >> and return and I make use of the many monad centric modules that exist but I also am under the impression that I can add as many other functions to my Monad class as I need to do what I need to do, is that correct?

I would therefore like some way to create an initial "thing" that contains the handle passed in to the function so that the >>= invocations can be as clean as possible because somewhere in my mind I can feel code resembling something like this:

getHIP :: Handle -> MyMonad PktHIP getHIP h = do    -- science fiction code starts now!

   let rs = ... --- record state monad thing with "h" and "PktHIP"

   getInt 1 rs hipProtoVer >>    getNTS   rs hipSvrVer >>    getInt 4 rs hipThreadId >>    getBS  8 rs hipScramble >>    skip 1 >>       :       : ...etc    return $ theHIP

getInt :: Int -> ST ? -> (PktHIP -> PktHIP) -> MyMonad PktHIP getInt len state fmod = do    val <- readStream ("h from state") len let state' = modify state by setting field "fmod" to "val"       return state'

Problems / things I am clueless about how to do here

 |1| how to create "something" that each >>= can modify (state monad instance?)  |2| how to put the Handle "h" somewhere it can be read on each read action  |3| everything else!!!

So, any ideas, examples etc. would be most enlightening and gratefully absorbed! Sean Charles. :)

_______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners