Fix formatting

ipython-kernel/src/IHaskell/IPython/ZeroMQ.hs

@@ -5,13 +5,13 @@
 -- The "ZeroMQ" module abstracts away the low-level 0MQ based interface with IPython, replacing it
 -- instead with a Haskell Channel based interface. The `serveProfile` function takes a IPython
 -- profile specification and returns the channel interface to use.
-module IHaskell.IPython.ZeroMQ
-       ( ZeroMQInterface(..)
-       , ZeroMQStdin(..)
-       , serveProfile
-       , serveStdin
-       , ZeroMQEphemeralPorts
-       , withEphemeralPorts
+module IHaskell.IPython.ZeroMQ (
+    ZeroMQInterface(..),
+    ZeroMQStdin(..),
+    serveProfile,
+    serveStdin,
+    ZeroMQEphemeralPorts,
+    withEphemeralPorts,
     ) where
 
 import           Control.Concurrent
@@ -68,7 +68,8 @@ newZeroMQInterface key = do
   controlReqChan <- dupChan shellReqChan
   controlRepChan <- dupChan shellRepChan
   iopubChan <- newChan
-  return $! Channels { shellRequestChannel = shellReqChan
+  return $! Channels
+    { shellRequestChannel = shellReqChan
     , shellReplyChannel = shellRepChan
     , controlRequestChannel = controlReqChan
     , controlReplyChannel = controlRepChan
@@ -100,10 +101,11 @@ serveProfile profile debug = do
 
   return channels
 
--- | Describes ports used when creating an ephemeral ZeroMQ session.
--- Used to generate the ipython JSON config file.
-data ZeroMQEphemeralPorts
-   = ZeroMQEphemeralPorts { ephHbPort      :: !Port
+-- | Describes ports used when creating an ephemeral ZeroMQ session. Used to generate the ipython
+-- JSON config file.
+data ZeroMQEphemeralPorts =
+       ZeroMQEphemeralPorts
+         { ephHbPort :: !Port
          , ephControlPort :: !Port
          , ephShellPort :: !Port
          , ephIOPubPort :: !Port
@@ -112,7 +114,8 @@ data ZeroMQEphemeralPorts
 
 instance ToJSON ZeroMQEphemeralPorts where
   toJSON ports =
-    object [ "ip"           .= ("127.0.0.1" :: String)
+    object
+      [ "ip" .= ("127.0.0.1" :: String)
       , "transport" .= TCP
       , "control_port" .= ephControlPort ports
       , "hb_port" .= ephHbPort ports
@@ -123,7 +126,8 @@ instance ToJSON ZeroMQEphemeralPorts where
 
 parsePort :: String -> Maybe Int
 parsePort s = readMaybe num
-  where num = reverse (takeWhile isNumber (reverse s))
+  where
+    num = reverse (takeWhile isNumber (reverse s))
 
 bindLocalEphemeralPort :: Socket a -> IO Int
 bindLocalEphemeralPort socket = do
@@ -135,15 +139,19 @@ bindLocalEphemeralPort socket = do
     Just endpointIndex ->
       return endpointIndex
 
--- | Run session for communicating with an IPython instance on ephemerally allocated
--- ZMQ4 sockets.  The sockets will be closed when the callback returns.
+-- | Run session for communicating with an IPython instance on ephemerally allocated ZMQ4 sockets.
+-- The sockets will be closed when the callback returns.
 withEphemeralPorts :: ByteString
+                   -> 
                       -- ^ HMAC encryption key
-                   -> Bool
+                      Bool
+                                           -> 
                                               -- ^ Print debug output
-                   -> (ZeroMQEphemeralPorts -> ZeroMQInterface -> IO a)
-                      -- ^ Callback that takes the interface to the sockets.
-                   -> IO a
+                                              (ZeroMQEphemeralPorts -> ZeroMQInterface -> IO a)
+                                                                  -> 
+                                                                     -- ^ Callback that takes the
+                                                                     -- interface to the sockets.
+                                                                     IO a
 withEphemeralPorts key debug callback = do
   channels <- newZeroMQInterface key
   -- Create the ZMQ4 context
@@ -153,19 +161,13 @@ withEphemeralPorts key debug callback = do
       withSocket context Router $ \controlportSocket -> do
         withSocket context Router $ \shellportSocket -> do
           withSocket context Pub $ \iopubSocket -> do
-
             -- Bind each socket to a local port, getting the port chosen.
             hbPort <- bindLocalEphemeralPort heartbeatSocket
             controlPort <- bindLocalEphemeralPort controlportSocket
             shellPort <- bindLocalEphemeralPort shellportSocket
             iopubPort <- bindLocalEphemeralPort iopubSocket
             -- Create object to store ephemeral ports
-       let ports = ZeroMQEphemeralPorts { ephHbPort      = hbPort
-                                        , ephControlPort = controlPort
-                                        , ephShellPort   = shellPort
-                                        , ephIOPubPort   = iopubPort
-                                        , ephSignatureKey = key
-                                        }
+            let ports = ZeroMQEphemeralPorts { ephHbPort = hbPort, ephControlPort = controlPort, ephShellPort = shellPort, ephIOPubPort = iopubPort, ephSignatureKey = key }
             -- Launch actions to listen to communicate between channels and cockets.
             _ <- forkIO $ forever $ heartbeat channels heartbeatSocket
             _ <- forkIO $ forever $ control debug channels controlportSocket
@@ -250,19 +252,15 @@ trySendMessage :: Sender a => String -> Bool -> ByteString -> Socket a -> Messag
 trySendMessage nm debug hmacKey socket message = do
   let zmqErrorHandler :: ZMQError -> IO Bool
       zmqErrorHandler e
-          -- Ignore errors if we cannot send.
-          -- We may want to forward this to the thread that tried put the message
-          -- in the Chan initially.
+        -- Ignore errors if we cannot send. We may want to forward this to the thread that tried put the
+        -- message in the Chan initially.
         | errno e == 38 = return False
         | otherwise = throwIO e
-  (sendMessage debug hmacKey socket message >> return True)
-    `catch` zmqErrorHandler
-
+  (sendMessage debug hmacKey socket message >> return True) `catch` zmqErrorHandler
 
--- | Send messages via the iopub channel.
--- This reads messages from the ZeroMQ iopub interface
--- channel and then writes the messages to the socket.
--- This is a checked implementation which will stop if the socket is closed.
+-- | Send messages via the iopub channel. This reads messages from the ZeroMQ iopub interface
+-- channel and then writes the messages to the socket. This is a checked implementation which will
+-- stop if the socket is closed.
 checkedIOpub :: Bool -> ZeroMQInterface -> Socket Pub -> IO ()
 checkedIOpub debug channels socket = do
   msg <- readChan (iopubChannel channels)