diff --git a/test/hs/TestClient.hs b/test/hs/TestClient.hs
index 35e8397..2b9254b 100644
--- a/test/hs/TestClient.hs
+++ b/test/hs/TestClient.hs
@@ -23,6 +23,7 @@
 import Control.Exception
 import Control.Monad
 import Data.Functor
+import Data.List.Split
 import Data.String
 import Network
 import System.Environment
@@ -80,10 +81,10 @@
 runClient p = do
   let prot = (p,p)
   putStrLn "Starting Tests"
-              
+
   -- VOID Test
   Client.testVoid prot
-  
+
   -- String Test
   s <- Client.testString prot "Test"
   when (s /= "Test") exitFailure
@@ -91,11 +92,11 @@
   -- Byte Test
   byte <- Client.testByte prot 1
   when (byte /= 1) exitFailure
-  
+
   -- I32 Test
   i32 <- Client.testI32 prot (-1)
   when (i32 /= -1) exitFailure
-  
+
   -- I64 Test
   i64 <- Client.testI64 prot (-34359738368)
   when (i64 /= -34359738368) exitFailure
@@ -110,7 +111,7 @@
                        , xtruct_i32_thing    = -3
                        , xtruct_i64_thing    = -5
                        }
-  structOut <- Client.testStruct prot structIn 
+  structOut <- Client.testStruct prot structIn
   when (structIn /= structOut) exitFailure
 
   -- Nested Struct Test
@@ -120,22 +121,22 @@
                       }
   nestOut <- Client.testNest prot nestIn
   when (nestIn /= nestOut) exitSuccess
-  
+
   -- Map Test
   let mapIn = Map.fromList $ map (\i -> (i, i-10)) [1..5]
   mapOut <- Client.testMap prot mapIn
   when (mapIn /= mapOut) exitSuccess
-  
+
   -- Set Test
   let setIn = Set.fromList [-2..3]
   setOut <- Client.testSet prot setIn
   when (setIn /= setOut) exitFailure
-  
+
   -- List Test
   let listIn = Vector.fromList [-2..3]
   listOut <- Client.testList prot listIn
   when (listIn /= listOut) exitFailure
-  
+
   -- Enum Test
   numz1 <- Client.testEnum prot ONE
   when (numz1 /= ONE) exitFailure
@@ -149,26 +150,26 @@
   -- Typedef Test
   uid <- Client.testTypedef prot 309858235082523
   when (uid /= 309858235082523) exitFailure
-  
+
   -- Nested Map Test
   _ <- Client.testMapMap prot 1
-  
+
   -- Exception Test
   exn1 <- try $ Client.testException prot "Xception"
   case exn1 of
     Left (Xception _ _) -> return ()
     _ -> putStrLn (show exn1) >> exitFailure
-  
+
   exn2 <- try $ Client.testException prot "TException"
   case exn2 of
     Left (_ :: SomeException) -> return ()
     Right _ -> exitFailure
-  
+
   exn3 <- try $ Client.testException prot "success"
   case exn3 of
     Left (_ :: SomeException) -> exitFailure
     Right _ -> return ()
-  
+
   -- Multi Exception Test
   multi1 <- try $ Client.testMultiException prot "Xception" "test 1"
   case multi1 of
@@ -197,24 +198,24 @@
             Binary  -> runClient $ BinaryProtocol handle
             Compact -> runClient $ CompactProtocol handle
             JSON    -> runClient $ JSONProtocol handle
-      replicateM_ testLoops client      
+      replicateM_ testLoops client
       putStrLn "COMPLETED SUCCESSFULLY"
 
 parseFlags :: [String] -> Options -> Maybe Options
+parseFlags (flag : flags) opts = do
+  let pieces = splitOn "=" flag
+  case pieces of
+    "--port" : arg : _ -> parseFlags flags opts{ port = read arg }
+    "--domain-socket" : arg : _ -> parseFlags flags opts{ domainSocket = read arg }
+    "--host" : arg : _ -> parseFlags flags opts{ host = arg }
+    "--transport" : arg : _ -> parseFlags flags opts{ transport = arg }
+    "--protocol" : arg : _ -> parseFlags flags opts{ protocol = getProtocol arg }
+    "--h" : _ -> Nothing
+    "--help" : _ -> Nothing
+    "--ssl" : _ -> parseFlags flags opts{ ssl = True }
+    "--processor-events" : _ -> parseFlags flags opts
 parseFlags (flag : arg : flags) opts
-  | flag == "--port"          = parseFlags flags opts{ port = read arg }
-  | flag == "--domain-socket" = parseFlags flags opts{ domainSocket = arg }
-  | flag == "--host"          = parseFlags flags opts{ host = arg }
-  | flag == "--transport"     = parseFlags flags opts{ transport = arg }
-  | flag == "--protocol"      = parseFlags flags opts{ protocol = getProtocol arg }
-  | flag == "-n" ||
-    flag == "--testloops"     = parseFlags flags opts{ testLoops = read arg }
-parseFlags (flag : flags) opts
-  | flag == "-h"     = Nothing
-  | flag == "--help" = Nothing
-  | flag == "--ssl"  = parseFlags flags opts{ ssl = True }
-  | flag == "--processor-events" ||
-    otherwise = parseFlags flags opts
+  | flag == "-n"                    = parseFlags flags opts{ testLoops = read arg }
 parseFlags [] opts = Just opts
 
 showHelp :: IO ()
@@ -223,7 +224,7 @@
   \  -h [ --help ]               produce help message\n\
   \  --host arg (=localhost)     Host to connect\n\
   \  --port arg (=9090)          Port number to connect\n\
-  \  --domain-socket arg         Domain Socket (e.g. /tmp/ThriftTest.thrift),\n\ 
+  \  --domain-socket arg         Domain Socket (e.g. /tmp/ThriftTest.thrift),\n\
   \                              instead of host and port\n\
   \  --transport arg (=buffered) Transport: buffered, framed, http, evhttp\n\
   \  --protocol arg (=binary)    Protocol: binary, compact, json\n\
diff --git a/test/hs/TestServer.hs b/test/hs/TestServer.hs
index 340b58b..e3f3241 100644
--- a/test/hs/TestServer.hs
+++ b/test/hs/TestServer.hs
@@ -25,6 +25,7 @@
 import Data.Functor
 import Data.HashMap.Strict (HashMap)
 import Data.List
+import Data.List.Split
 import Data.String
 import Network
 import System.Environment
@@ -57,7 +58,7 @@
   , ssl          :: Bool
   , workers      :: Int
   }
-  
+
 data ServerType = Simple
                 | ThreadPool
                 | Threaded
@@ -93,42 +94,42 @@
   }
 
 stringifyMap :: (Show a, Show b) => Map.HashMap a b -> String
-stringifyMap = intercalate ", " . map joinKV . Map.toList
+stringifyMap = Data.List.intercalate ", " . Data.List.map joinKV . Map.toList
   where joinKV (k, v) = show k ++ " => " ++ show v
 
 stringifySet :: Show a => Set.HashSet a -> String
-stringifySet = intercalate ", " . map show . Set.toList
+stringifySet = Data.List.intercalate ", " . Data.List.map show . Set.toList
 
 stringifyList :: Show a => Vector.Vector a -> String
-stringifyList = intercalate ", " . map show . Vector.toList
+stringifyList = Data.List.intercalate ", " . Data.List.map show . Vector.toList
 
 data TestHandler = TestHandler
-instance ThriftTest_Iface TestHandler where  
-  testVoid _ = putStrLn "testVoid()"
+instance ThriftTest_Iface TestHandler where
+  testVoid _ = System.IO.putStrLn "testVoid()"
 
   testString _ s = do
-    putStrLn $ "testString(" ++ show s ++ ")"
+    System.IO.putStrLn $ "testString(" ++ show s ++ ")"
     return s
 
   testByte _ x = do
-    putStrLn $ "testByte(" ++ show x ++ ")"
+    System.IO.putStrLn $ "testByte(" ++ show x ++ ")"
     return x
 
   testI32 _ x = do
-    putStrLn $ "testI32(" ++ show x ++ ")"
+    System.IO.putStrLn $ "testI32(" ++ show x ++ ")"
     return x
 
   testI64 _ x = do
-    putStrLn $ "testI64(" ++ show x ++ ")"
+    System.IO.putStrLn $ "testI64(" ++ show x ++ ")"
     return x
-    
+
   testDouble _ x = do
-    putStrLn $ "testDouble(" ++ show x ++ ")"
+    System.IO.putStrLn $ "testDouble(" ++ show x ++ ")"
     return x
 
   testStruct _ struct@Xtruct{..} = do
-    putStrLn $ "testStruct({" ++ show xtruct_string_thing
-                      ++ ", " ++ show xtruct_byte_thing 
+    System.IO.putStrLn $ "testStruct({" ++ show xtruct_string_thing
+                      ++ ", " ++ show xtruct_byte_thing
                       ++ ", " ++ show xtruct_i32_thing
                       ++ ", " ++ show xtruct_i64_thing
                       ++ "})"
@@ -136,7 +137,7 @@
 
   testNest _ nest@Xtruct2{..} = do
     let Xtruct{..} = xtruct2_struct_thing
-    putStrLn $ "testNest({" ++ show xtruct2_byte_thing
+    System.IO.putStrLn $ "testNest({" ++ show xtruct2_byte_thing
                    ++ "{, " ++ show xtruct_string_thing
                    ++  ", " ++ show xtruct_byte_thing
                    ++  ", " ++ show xtruct_i32_thing
@@ -145,31 +146,31 @@
     return nest
 
   testMap _ m = do
-    putStrLn $ "testMap({" ++ stringifyMap m ++ "})"
+    System.IO.putStrLn $ "testMap({" ++ stringifyMap m ++ "})"
     return m
-            
+
   testStringMap _ m = do
-    putStrLn $ "testStringMap(" ++ stringifyMap m ++ "})"
+    System.IO.putStrLn $ "testStringMap(" ++ stringifyMap m ++ "})"
     return m
 
   testSet _ x = do
-    putStrLn $ "testSet({" ++ stringifySet x ++ "})"
+    System.IO.putStrLn $ "testSet({" ++ stringifySet x ++ "})"
     return x
 
   testList _ x = do
-    putStrLn $ "testList(" ++ stringifyList x ++ "})"
+    System.IO.putStrLn $ "testList(" ++ stringifyList x ++ "})"
     return x
 
   testEnum _ x = do
-    putStrLn $ "testEnum(" ++ show x ++ ")"
+    System.IO.putStrLn $ "testEnum(" ++ show x ++ ")"
     return x
 
   testTypedef _ x = do
-    putStrLn $ "testTypedef(" ++ show x ++ ")"
+    System.IO.putStrLn $ "testTypedef(" ++ show x ++ ")"
     return x
 
   testMapMap _ x = do
-    putStrLn $ "testMapMap(" ++ show x ++ ")"
+    System.IO.putStrLn $ "testMapMap(" ++ show x ++ ")"
     return $ Map.fromList [ (-4, Map.fromList [ (-4, -4)
                                               , (-3, -3)
                                               , (-2, -2)
@@ -183,7 +184,7 @@
                           ]
 
   testInsanity _ x = do
-    putStrLn "testInsanity()"
+    System.IO.putStrLn "testInsanity()"
     return $ Map.fromList [ (1, Map.fromList [ (TWO  , x)
                                              , (THREE, x)
                                              ])
@@ -192,32 +193,32 @@
                           ]
 
   testMulti _ byte i32 i64 _ _ _ = do
-    putStrLn "testMulti()"
+    System.IO.putStrLn "testMulti()"
     return Xtruct{ xtruct_string_thing = Text.pack "Hello2"
                  , xtruct_byte_thing   = byte
                  , xtruct_i32_thing    = i32
                  , xtruct_i64_thing    = i64
                  }
-                                        
+
   testException _ s = do
-    putStrLn $ "testException(" ++ show s ++ ")"
+    System.IO.putStrLn $ "testException(" ++ show s ++ ")"
     case s of
       "Xception"   -> throw $ Xception 1001 s
       "TException" -> throw ThriftException
       _ -> return ()
 
   testMultiException _ s1 s2 = do
-    putStrLn $ "testMultiException(" ++ show s1 ++ ", " ++ show s2 ++  ")"
+    System.IO.putStrLn $ "testMultiException(" ++ show s1 ++ ", " ++ show s2 ++  ")"
     case s1 of
-      "Xception"   -> throw $ Xception 1001 "This is an Xception" 
-      "Xception2"  -> throw $ Xception2 2002 default_Xtruct 
+      "Xception"   -> throw $ Xception 1001 "This is an Xception"
+      "Xception2"  -> throw $ Xception2 2002 default_Xtruct
       "TException" -> throw ThriftException
       _ -> return default_Xtruct{ xtruct_string_thing = s2 }
 
   testOneway _ i = do
-    putStrLn $ "testOneway(" ++ show i ++ "): Sleeping..."
+    System.IO.putStrLn $ "testOneway(" ++ show i ++ "): Sleeping..."
     sleep (fromIntegral i)
-    putStrLn $ "testOneway(" ++ show i ++ "): done sleeping!"
+    System.IO.putStrLn $ "testOneway(" ++ show i ++ "): done sleeping!"
 
 main :: IO ()
 main = do
@@ -225,7 +226,7 @@
   case options of
     Nothing -> showHelp
     Just Options{..} -> do
-      putStrLn $ "Starting \"" ++ show serverType ++ "\" server (" ++
+      System.IO.putStrLn $ "Starting \"" ++ show serverType ++ "\" server (" ++
         show transport ++ ") listen on: " ++ domainSocket ++ show port
       case protocol of
         Binary  -> runServer BinaryProtocol port
@@ -238,23 +239,25 @@
           return (p h, p h)
 
 parseFlags :: [String] -> Options -> Maybe Options
+parseFlags (flag : flags) opts = do
+  let pieces = splitOn "=" flag
+  case pieces of
+    "--port" : arg : _ -> parseFlags flags opts{ port = read arg }
+    "--domain-socket" : arg : _ -> parseFlags flags opts{ domainSocket = read arg }
+    "--server-type" : arg : _ -> parseFlags flags opts{ serverType = fromString arg }
+    "--transport" : arg : _ -> parseFlags flags opts{ transport = arg }
+    "--protocol" : arg : _ -> parseFlags flags opts{ protocol = getProtocol arg }
+    "--workers" : arg : _ -> parseFlags flags opts{ workers = read arg }
+    "--h" : _ -> Nothing
+    "--help" : _ -> Nothing
+    "--ssl" : _ -> parseFlags flags opts{ ssl = True }
+    "--processor-events" : _ -> parseFlags flags opts
 parseFlags (flag : arg : flags) opts
-  | flag == "--port"          = parseFlags flags opts{ port = read arg }
-  | flag == "--domain-socket" = parseFlags flags opts{ domainSocket = arg }
-  | flag == "--server-type"   = parseFlags flags opts{ serverType = fromString arg }
-  | flag == "--transport"     = parseFlags flags opts{ transport = arg }
-  | flag == "--protocol"      = parseFlags flags opts{ protocol = getProtocol arg }
-  | flag == "-n" ||
-    flag == "--workers"       = parseFlags flags opts{ workers = read arg }
-parseFlags (flag : flags) opts
-  | flag == "-h"     = Nothing
-  | flag == "--help" = Nothing
-  | flag == "--ssl"  = parseFlags flags opts{ ssl = True }
-  | flag == "--processor-events" = parseFlags flags opts
+  | flag == "-n"                     = parseFlags flags opts{ workers = read arg }
 parseFlags [] opts = Just opts
 
 showHelp :: IO ()
-showHelp = putStrLn
+showHelp = System.IO.putStrLn
   "Allowed options:\n\
   \  -h [ --help ]               produce help message\n\
   \  --port arg (=9090)          Port number to listen\n\
@@ -265,5 +268,5 @@
   \  --protocol arg (=binary)    protocol: binary, compact, json\n\
   \  --ssl                       Encrypted Transport using SSL\n\
   \  --processor-events          processor-events\n\
-  \  -n [ --workers ] arg (=4)   Number of thread pools workers. Only valid for\n\ 
+  \  -n [ --workers ] arg (=4)   Number of thread pools workers. Only valid for\n\
   \                              thread-pool server type"
\ No newline at end of file