Merge pull request #445 from gibiansky/format-all-src

Format all src

.travis.yml

@@ -36,7 +36,7 @@ install:
    if [ ${GHCVER%.*} = "7.8" ]; then
      travis_retry cabal install arithmoi==0.4.* -fllvm
      travis_retry git clone http://www.github.com/gibiansky/hindent
-     cd hindent && cabal install && cd ..
+     cd hindent && travis_retry cabal install && cd ..
    fi
 
 # Here starts the actual work to be performed for the package under test; any command which exits with a non-zero exit code causes the build to fail.

ihaskell-display/ihaskell-aeson/IHaskell/Display/Aeson.hs

 {-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, QuasiQuotes #-}
+
 module IHaskell.Display.Aeson () where
 
-import ClassyPrelude
-import Data.Textual.Encoding
-import Data.Aeson
-import Data.Aeson.Encode.Pretty
-import Data.String.Here
+import           ClassyPrelude
+import           Data.Textual.Encoding
+import           Data.Aeson
+import           Data.Aeson.Encode.Pretty
+import           Data.String.Here
 
-import IHaskell.Display
+import           IHaskell.Display
 
 instance IHaskellDisplay Value where
   display renderable = return $ Display [plain json, html dom]
-    where 
+    where
       json = unpack $ decodeUtf8 $ encodePretty renderable
       dom = [i|<div class="highlight-code" id="javascript">${json}</div>|]

ihaskell-display/ihaskell-basic/IHaskell/Display/Basic.hs

 {-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Basic () where
 
-import IHaskell.Display
+import           IHaskell.Display
 
-import Text.Printf
+import           Text.Printf
 
 instance Show a => IHaskellDisplay (Maybe a) where
   display just = return $ Display [stringDisplay, htmlDisplay]
-    where 
+    where
       stringDisplay = plain (show just)
       htmlDisplay = html str
-      str = case just of
-        Nothing -> "<span style='color: red; font-weight: bold;'>Nothing</span>"
-        Just x -> printf "<span style='color: green; font-weight: bold;'>Just</span><span style='font-family: monospace;'>%s</span>" (show x)
+      str =
+        case just of
+          Nothing -> "<span style='color: red; font-weight: bold;'>Nothing</span>"
+          Just x -> printf
+                      "<span style='color: green; font-weight: bold;'>Just</span><span style='font-family: monospace;'>%s</span>"
+                      (show x)

ihaskell-display/ihaskell-blaze/IHaskell/Display/Blaze.hs

 {-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Blaze () where
 
-import IHaskell.Display
+import           IHaskell.Display
 
-import Text.Printf
-import Text.Blaze.Html
-import Text.Blaze.Renderer.Pretty
-import Text.Blaze.Internal
-import Control.Monad
+import           Text.Printf
+import           Text.Blaze.Html
+import           Text.Blaze.Renderer.Pretty
+import           Text.Blaze.Internal
+import           Control.Monad
 
 instance IHaskellDisplay (MarkupM a) where
   display val = return $ Display [stringDisplay, htmlDisplay]
-    where 
+    where
       str = renderMarkup (void val)
       stringDisplay = plain str
       htmlDisplay = html str

ihaskell-display/ihaskell-charts/IHaskell/Display/Charts.hs

 {-# LANGUAGE NoImplicitPrelude, CPP #-}
+
 module IHaskell.Display.Charts () where
 
-import ClassyPrelude
+import           ClassyPrelude
 
-import System.Directory
-import Data.Default.Class
-import Graphics.Rendering.Chart.Renderable
-import Graphics.Rendering.Chart.Backend.Cairo
+import           System.Directory
+import           Data.Default.Class
+import           Graphics.Rendering.Chart.Renderable
+import           Graphics.Rendering.Chart.Backend.Cairo
 import qualified Data.ByteString.Char8 as Char
-import System.IO.Unsafe
+import           System.IO.Unsafe
 
-import IHaskell.Display
+import           IHaskell.Display
 
 width :: Width
 width = 450
@@ -22,8 +23,8 @@ instance IHaskellDisplay (Renderable a) where
   display renderable = do
     pngDisp <- chartData renderable PNG
 
-    -- We can add `svg svgDisplay` to the output of `display`,
-    -- but SVGs are not resizable in the IPython notebook.
+    -- We can add `svg svgDisplay` to the output of `display`, but SVGs are not resizable in the IPython
+    -- notebook.
     svgDisp <- chartData renderable SVG
 
     return $ Display [pngDisp, svgDisp]
@@ -34,17 +35,17 @@ chartData renderable format = do
 
   -- Write the PNG image.
   let filename = ".ihaskell-chart.png"
-      opts = def{_fo_format = format, _fo_size = (width, height)}
-      toFile = renderableToFile opts
+      opts = def { _fo_format = format, _fo_size = (width, height) }
+  mkFile opts filename renderable
 
+  -- Convert to base64.
+  imgData <- readFile $ fpFromString filename
+  return $
+    case format of
+      PNG -> png width height $ base64 imgData
+      SVG -> svg $ Char.unpack imgData
 #if MIN_VERSION_Chart_cairo(1,3,0)
-  toFile filename renderable
+mkFile opts filename renderable = renderableToFile opts filename renderable
 #else
-  toFile renderable filename
+mkFile opts filename renderable = renderableToFile opts renderable filename
 #endif
-
-  -- Convert to base64.
-  imgData <- readFile $ fpFromString filename
-  return $ case format of
-    PNG -> png width height $ base64 imgData
-    SVG -> svg $ Char.unpack imgData

ihaskell-display/ihaskell-diagrams/IHaskell/Display/Diagrams.hs

-{-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances  #-}
+{-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Diagrams (diagram, animation) where
 
-import ClassyPrelude
+import           ClassyPrelude
 
-import System.Directory
+import           System.Directory
 import qualified Data.ByteString.Char8 as Char
-import System.IO.Unsafe
+import           System.IO.Unsafe
 
-import Diagrams.Prelude
-import Diagrams.Backend.Cairo
+import           Diagrams.Prelude
+import           Diagrams.Backend.Cairo
 
-import IHaskell.Display
-import IHaskell.Display.Diagrams.Animation
+import           IHaskell.Display
+import           IHaskell.Display.Diagrams.Animation
 
 instance IHaskellDisplay (QDiagram Cairo R2 Any) where
   display renderable = do
@@ -36,11 +37,13 @@ diagramData renderable format = do
 
   -- Convert to base64.
   imgData <- readFile $ fpFromString filename
-  let value = case format of
-        PNG -> png (floor imgWidth) (floor imgHeight) $ base64 imgData
-        SVG -> svg $ Char.unpack imgData
+  let value =
+        case format of
+          PNG -> png (floor imgWidth) (floor imgHeight) $ base64 imgData
+          SVG -> svg $ Char.unpack imgData
 
   return value
+
   where
     extension SVG = "svg"
     extension PNG = "png"

ihaskell-display/ihaskell-diagrams/IHaskell/Display/Diagrams/Animation.hs

-{-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances  #-}
+{-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Diagrams.Animation (animation) where
 
-import ClassyPrelude hiding (filename)
+import           ClassyPrelude hiding (filename)
 
-import Diagrams.Prelude
-import Diagrams.Backend.Cairo
-import Diagrams.Backend.Cairo.CmdLine (GifOpts (..))
-import Diagrams.Backend.CmdLine (DiagramOpts (..), mainRender)
+import           Diagrams.Prelude
+import           Diagrams.Backend.Cairo
+import           Diagrams.Backend.Cairo.CmdLine (GifOpts(..))
+import           Diagrams.Backend.CmdLine (DiagramOpts(..), mainRender)
 
-import IHaskell.Display
+import           IHaskell.Display
 
 instance IHaskellDisplay (QAnimation Cairo R2 Any) where
   display renderable = do
     gif <- animationData renderable
     return $ Display [html $ "<img src=\"data:image/gif;base64,"
-                               ++ gif ++ "\" />"]
+                             ++ gif ++ "\" />"]
 
 animationData :: Animation Cairo R2 -> IO String
 animationData renderable = do
@@ -37,16 +38,12 @@ animationData renderable = do
 
   -- Write the image.
   let filename = ".ihaskell-diagram.gif"
-      diagOpts = DiagramOpts {
-                             _width = Just . ceiling $ imgWidth
-                           , _height = Just . ceiling $ imgHeight
-                           , _output = filename
-                           }
-      gifOpts = GifOpts {
-                  _dither = True
-                , _noLooping = False
-                , _loopRepeat = Nothing
-                }
+      diagOpts = DiagramOpts
+        { _width = Just . ceiling $ imgWidth
+        , _height = Just . ceiling $ imgHeight
+        , _output = filename
+        }
+      gifOpts = GifOpts { _dither = True, _noLooping = False, _loopRepeat = Nothing }
   mainRender (diagOpts, gifOpts) frameSet
 
   -- Convert to ascii represented base64 encoding

ihaskell-display/ihaskell-hatex/IHaskell/Display/Hatex.hs

 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleInstances #-}
+
 -- | Provides 'IHaskellDisplay' instances for 'LaTeX' and 'LaTeXT'.
 module IHaskell.Display.Hatex () where
 
-import IHaskell.Display
-import Text.LaTeX
+import           IHaskell.Display
+import           Text.LaTeX
 import qualified Data.Text as T
 
 instance IHaskellDisplay LaTeX where
   display = display . IHaskell.Display.latex . T.unpack . render
 
 instance (a ~ (), IO ~ io) => IHaskellDisplay (LaTeXT io a) where
-    display ma = display =<< execLaTeXT ma
+  display ma = display =<< execLaTeXT ma

ihaskell-display/ihaskell-juicypixels/IHaskell/Display/Juicypixels.hs

-{-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances  #-}
-module IHaskell.Display.Juicypixels 
-     ( module IHaskell.Display
-     , module Codec.Picture
-     ) where
-
-import Codec.Picture
-import ClassyPrelude
-import IHaskell.Display
-import System.Directory
-import System.IO.Unsafe
+{-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, FlexibleInstances #-}
+
+module IHaskell.Display.Juicypixels (module IHaskell.Display, module Codec.Picture) where
+
+import           Codec.Picture
+import           ClassyPrelude
+import           IHaskell.Display
+import           System.Directory
+import           System.IO.Unsafe
 
 -- instances
-instance IHaskellDisplay DynamicImage where display = displayImageAsJpg 
-instance IHaskellDisplay (Image Pixel8) where display = displayImageAsJpg . ImageY8
-instance IHaskellDisplay (Image Pixel16) where display = displayImageAsJpg . ImageY16	
-instance IHaskellDisplay (Image PixelF) where display =  displayImageAsJpg . ImageYF
-instance IHaskellDisplay (Image PixelYA8) where display = displayImageAsJpg . ImageYA8
-instance IHaskellDisplay (Image PixelYA16) where display = displayImageAsJpg . ImageYA16
-instance IHaskellDisplay (Image PixelRGB8) where display = displayImageAsJpg . ImageRGB8
-instance IHaskellDisplay (Image PixelRGB16) where display = displayImageAsJpg . ImageRGB16
-instance IHaskellDisplay (Image PixelRGBF) where display =  displayImageAsJpg . ImageRGBF
-instance IHaskellDisplay (Image PixelRGBA8) where display = displayImageAsJpg . ImageRGBA8
-instance IHaskellDisplay (Image PixelRGBA16) where display = displayImageAsJpg . ImageRGBA16	
-instance IHaskellDisplay (Image PixelYCbCr8) where display = displayImageAsJpg . ImageYCbCr8
-instance IHaskellDisplay (Image PixelCMYK8) where display = displayImageAsJpg . ImageCMYK8 
-instance IHaskellDisplay (Image PixelCMYK16) where display = displayImageAsJpg . ImageCMYK16	
+instance IHaskellDisplay DynamicImage where
+  display = displayImageAsJpg
+
+instance IHaskellDisplay (Image Pixel8) where
+  display = displayImageAsJpg . ImageY8
+
+instance IHaskellDisplay (Image Pixel16) where
+  display = displayImageAsJpg . ImageY16
+
+instance IHaskellDisplay (Image PixelF) where
+  display = displayImageAsJpg . ImageYF
+
+instance IHaskellDisplay (Image PixelYA8) where
+  display = displayImageAsJpg . ImageYA8
+
+instance IHaskellDisplay (Image PixelYA16) where
+  display = displayImageAsJpg . ImageYA16
+
+instance IHaskellDisplay (Image PixelRGB8) where
+  display = displayImageAsJpg . ImageRGB8
+
+instance IHaskellDisplay (Image PixelRGB16) where
+  display = displayImageAsJpg . ImageRGB16
+
+instance IHaskellDisplay (Image PixelRGBF) where
+  display = displayImageAsJpg . ImageRGBF
+
+instance IHaskellDisplay (Image PixelRGBA8) where
+  display = displayImageAsJpg . ImageRGBA8
+
+instance IHaskellDisplay (Image PixelRGBA16) where
+  display = displayImageAsJpg . ImageRGBA16
+
+instance IHaskellDisplay (Image PixelYCbCr8) where
+  display = displayImageAsJpg . ImageYCbCr8
+
+instance IHaskellDisplay (Image PixelCMYK8) where
+  display = displayImageAsJpg . ImageCMYK8
+
+instance IHaskellDisplay (Image PixelCMYK16) where
+  display = displayImageAsJpg . ImageCMYK16
 
 -- main rendering function
-displayImageAsJpg ::  DynamicImage -> IO Display
+displayImageAsJpg :: DynamicImage -> IO Display
 displayImageAsJpg renderable = do
   switchToTmpDir
 
@@ -40,30 +65,30 @@ displayImageAsJpg renderable = do
 
 -- The type DynamicImage does not have a function to extract width and height
 imWidth :: DynamicImage -> Int
-imWidth img  = w
-   where (w, h) = imWidthHeight img
+imWidth img = w
+  where
+    (w, h) = imWidthHeight img
 
 imHeight :: DynamicImage -> Int
 imHeight img = h
-   where (w, h) = imWidthHeight img
+  where
+    (w, h) = imWidthHeight img
 
 -- Helper functions to pattern match on the DynamicImage Constructors
 imWidthHeight :: DynamicImage -> (Int, Int)
-imWidthHeight (ImageY8 im)	= imWH im
-imWidthHeight (ImageY16 im)	= imWH im
-imWidthHeight (ImageYF im)	= imWH im
-imWidthHeight (ImageYA8 im)	= imWH im
+imWidthHeight (ImageY8 im) = imWH im
+imWidthHeight (ImageY16 im) = imWH im
+imWidthHeight (ImageYF im) = imWH im
+imWidthHeight (ImageYA8 im) = imWH im
 imWidthHeight (ImageYA16 im) = imWH im
-imWidthHeight (ImageRGB8 im) = imWH im	
-imWidthHeight (ImageRGB16 im) = imWH im	
-imWidthHeight (ImageRGBF im) = imWH im	
+imWidthHeight (ImageRGB8 im) = imWH im
+imWidthHeight (ImageRGB16 im) = imWH im
+imWidthHeight (ImageRGBF im) = imWH im
 imWidthHeight (ImageRGBA8 im) = imWH im
 imWidthHeight (ImageRGBA16 im) = imWH im
-imWidthHeight (ImageYCbCr8 im) = imWH im	
+imWidthHeight (ImageYCbCr8 im) = imWH im
 imWidthHeight (ImageCMYK8 im) = imWH im
 imWidthHeight (ImageCMYK16 im) = imWH im
 
 imWH :: (Image a) -> (Int, Int)
 imWH im = (imageWidth im, imageHeight im)
-
-

ihaskell-display/ihaskell-magic/IHaskell/Display/Magic.hs

 {-# LANGUAGE ViewPatterns, TypeSynonymInstances, FlexibleInstances #-}
+
 module IHaskell.Display.Magic () where
 
-import IHaskell.Display
-import Magic
+import           IHaskell.Display
+import           Magic
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Unsafe as B
 import qualified Data.ByteString.Base64 as Base64
 import qualified Data.ByteString.Char8 as Char
 import qualified Data.ByteString.UTF8 as B
 
-import Text.Read
-import Data.Char
+import           Text.Read
+import           Data.Char
 
 import qualified Data.Text as T
 import qualified Data.Text.Encoding as T
-import IHaskell.IPython.Types (MimeType(MimeSvg))
-import Data.ByteString.UTF8
+import           IHaskell.IPython.Types (MimeType(MimeSvg))
+import           Data.ByteString.UTF8
 
 instance IHaskellDisplay T.Text where
-    display = display . T.encodeUtf8
+  display = display . T.encodeUtf8
 
 instance IHaskellDisplay B.ByteString where
-    display x = do
-        m <- magicOpen []
-        magicLoadDefault m
-        f <- B.unsafeUseAsCStringLen x (magicCString m)
-        return $ Display [withClass (parseMagic f) x]
+  display x = do
+    m <- magicOpen []
+    magicLoadDefault m
+    f <- B.unsafeUseAsCStringLen x (magicCString m)
+    return $ Display [withClass (parseMagic f) x]
 
 b64 :: B.ByteString -> String
 b64 = Char.unpack . Base64.encode
@@ -34,7 +35,7 @@ withClass :: MagicClass -> B.ByteString -> DisplayData
 withClass SVG = DisplayData MimeSvg . T.decodeUtf8
 withClass (PNG w h) = png w h . T.decodeUtf8 . Base64.encode
 withClass JPG = jpg 400 300 . T.decodeUtf8 . Base64.encode
-withClass HTML = html . B.toString 
+withClass HTML = html . B.toString
 withClass LaTeX = latex . B.toString
 withClass _ = plain . B.toString
 
@@ -54,17 +55,20 @@ JPG
 
 -}
 parseMagic :: String -> MagicClass
-parseMagic f = case words f of
-    "SVG" : _ -> SVG
-    "PNG" : _image : _data :
-        (readMaybe -> Just w) : _x :
-        (readMaybe . takeWhile isDigit -> Just h) : _ -> PNG w h
-    "LaTeX" : _ -> LaTeX
-    "HTML" : _ -> HTML
-    "JPEG" : _ -> JPG
-    _ -> Unknown
-
+parseMagic f =
+  case words f of
+    "SVG":_                                                                                 -> SVG
+    "PNG":_image:_data:(readMaybe -> Just w):_x:(readMaybe . takeWhile isDigit -> Just h):_ -> PNG w
+                                                                                                 h
+    "LaTeX":_                                                                               -> LaTeX
+    "HTML":_                                                                                -> HTML
+    "JPEG":_                                                                                -> JPG
+    _                                                                                       -> Unknown
 
-data MagicClass =
-    SVG | PNG Int Int | JPG | HTML | LaTeX | Unknown
-    deriving Show
+data MagicClass = SVG
+                | PNG Int Int
+                | JPG
+                | HTML
+                | LaTeX
+                | Unknown
+  deriving Show

ihaskell-display/ihaskell-parsec/IHaskell/Display/Parsec.hs

 {-# LANGUAGE NoImplicitPrelude, TypeSynonymInstances, QuasiQuotes, FlexibleInstances, OverloadedStrings #-}
+
 module IHaskell.Display.Parsec () where
 
-import ClassyPrelude hiding (fromList)
-import System.Random
-import Data.String.Here
-import Data.HashMap.Strict as Map
+import           ClassyPrelude hiding (fromList)
+import           System.Random
+import           Data.String.Here
+import           Data.HashMap.Strict as Map
 
-import Text.Parsec (parse, sourceLine, sourceColumn)
-import Text.Parsec.String (Parser)
-import Text.Parsec.Error (errorPos, ParseError)
+import           Text.Parsec (parse, sourceLine, sourceColumn)
+import           Text.Parsec.String (Parser)
+import           Text.Parsec.Error (errorPos, ParseError)
 
-import Data.Aeson
+import           Data.Aeson
 
-import IHaskell.Display
+import           IHaskell.Display
 
 instance Show a => IHaskellDisplay (Parser a) where
   display renderable = return $ many [Display [javascript js], Display [html dom]]
-    where 
+    where
       dom = [hereFile|widget.html|]
       js = [hereFile|widget.js|]
 
@@ -25,25 +26,21 @@ data ParseText = ParseText String
 
 instance FromJSON ParseText where
   parseJSON (Object v) = ParseText <$> v .: "text"
-  parseJSON _          = fail "Expecting object"
+  parseJSON _ = fail "Expecting object"
 
 -- | Output of parsing.
 instance Show a => ToJSON (Either ParseError a) where
-  toJSON (Left err) = object [
-                        "status" .= ("error" :: String),
-                        "line" .= sourceLine (errorPos err),
-                        "col" .= sourceColumn (errorPos err),
-                        "msg" .= show err
-                      ]
-  toJSON (Right result) = object [
-                               "status" .= ("success" :: String),
-                               "result" .= show result
-                            ]
+  toJSON (Left err) = object
+                        [ "status" .= ("error" :: String)
+                        , "line" .= sourceLine (errorPos err)
+                        , "col" .= sourceColumn (errorPos err)
+                        , "msg" .= show err
+                        ]
+  toJSON (Right result) = object ["status" .= ("success" :: String), "result" .= show result]
 
 instance Show a => IHaskellWidget (Parser a) where
   -- Name for this widget.
   targetName _ = "parsec"
-
   -- When we rece
   comm widget (Object dict) publisher = do
     let key = "text" :: Text

ihaskell-display/ihaskell-rlangqq/IHaskell/Display/Rlangqq.hs

 {-# OPTIONS_GHC -fno-warn-missing-fields #-}
 {-# LANGUAGE TupleSections, TemplateHaskell #-}
-module IHaskell.Display.Rlangqq
-  ( module RlangQQ,
+
+module IHaskell.Display.Rlangqq (
+    module RlangQQ,
     rDisp,
     rDisplayAll,
     rOutputParsed,
     rOutput,
     getPlotNames,
     getCaptions,
-  ) where
+    ) where
 
-import RlangQQ
-import RlangQQ.ParseKnitted
+import           RlangQQ
+import           RlangQQ.ParseKnitted
 
-import System.Directory
-import System.FilePath
-import Data.Maybe
-import Data.List
-import Text.Read
+import           System.Directory
+import           System.FilePath
+import           Data.Maybe
+import           Data.List
+import           Text.Read
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Char8 as Char
 import qualified Data.ByteString.Base64 as Base64
-import IHaskell.Display
-import IHaskell.Display.Blaze () -- to confirm it's installed
+import           IHaskell.Display
+import           IHaskell.Display.Blaze () -- to confirm it's installed
 import qualified Text.Blaze.Html5 as H
 import qualified Text.Blaze.Html5.Attributes as H
-import Data.Monoid
-import Data.Char
-import Control.Monad
-import Data.Ord
-import Data.List.Split
-import Text.XFormat.Show hiding ((<>))
-import Control.Applicative
-import Control.Concurrent
-import Data.Monoid
-import Data.Typeable
+import           Data.Char
+import           Control.Monad
+import           Data.Ord
+import           Data.List.Split
+import           Text.XFormat.Show hiding ((<>))
+import           Control.Applicative
+import           Control.Concurrent
+import           Data.Monoid
+import           Data.Typeable
 
-import Control.Concurrent.STM
-import Language.Haskell.TH.Quote
+import           Control.Concurrent.STM
+import           Language.Haskell.TH.Quote
 
 -- | same as 'RlangQQ.r', but displays plots at the end too
-rDisp = QuasiQuoter { quoteExp = \s -> [| do
-  result <- $(quoteExp r s)
-  p <- rDisplayAll
-  printDisplay p
-  return result
-  |] }
+rDisp = QuasiQuoter { quoteExp = \s -> [|do
+                                           result <- $(quoteExp r s)
+                                           p <- rDisplayAll
+                                           printDisplay p
+                                           return result|] }
 
 rOutput :: IO [Int]
 rOutput = do
   fs <- mapMaybe (readMaybe <=< stripPrefix "raw" <=< stripSuffix ".md")
-    <$> getDirectoryContents "Rtmp"
-  fs' <- forM fs $ \f -> (,f) <$> getModificationTime (showf ("Rtmp/raw"%Int%".md") f)
+        <$> getDirectoryContents "Rtmp"
+  fs' <- forM fs $ \f -> (,f) <$> getModificationTime (showf ("Rtmp/raw" % Int % ".md") f)
   return $ map snd $ sortBy (flip (comparing fst)) fs'
 
 -- | like 'stripPrefix' except on the end
@@ -62,35 +61,33 @@ rOutputParsed :: IO [KnitInteraction]
 rOutputParsed = do
   ns <- rOutput
   case ns of
-    [] -> return []
-    n : _ -> parseKnitted <$> readFile (showf ("Rtmp/raw"%Int%".md") n)
-
+    []  -> return []
+    n:_ -> parseKnitted <$> readFile (showf ("Rtmp/raw" % Int % ".md") n)
 
 getPlotNames :: IO [String]
 getPlotNames = do
   interactions <- rOutputParsed
-  return [ p |  KnitInteraction _ is <- interactions, KnitImage _ p <- is ]
-            
+  return [p | KnitInteraction _ is <- interactions
+            , KnitImage _ p <- is]
+
 getCaptions :: IO [String]
 getCaptions = do
   interactions <- rOutputParsed
-  return [ c |  KnitInteraction _ is <- interactions,
-                KnitImage c _ <- is,
-                not (isBoringCaption c) ]
+  return
+    [c | KnitInteraction _ is <- interactions
+       , KnitImage c _ <- is
+       , not (isBoringCaption c)]
 
--- | true when the caption name looks like one knitr will automatically
--- generate
+-- | true when the caption name looks like one knitr will automatically generate
 isBoringCaption :: String -> Bool
-isBoringCaption s = maybe False
-                      (all isDigit)
-                      (stripPrefix "plot of chunk unnamed-chunk-" s)
+isBoringCaption s = maybe False (all isDigit) (stripPrefix "plot of chunk unnamed-chunk-" s)
 
 rDisplayAll :: IO Display
 rDisplayAll = do
- ns <- rOutputParsed
- imgs <- sequence [ displayInteraction o | KnitInteraction _ os <- ns, o <- os]
- display (mconcat imgs)
-
+  ns <- rOutputParsed
+  imgs <- sequence [displayInteraction o | KnitInteraction _ os <- ns
+                                         , o <- os]
+  display (mconcat imgs)
 
 displayInteraction :: KnitOutput -> IO Display
 displayInteraction (KnitPrint c) = display (plain c)
@@ -99,10 +96,11 @@ displayInteraction (KnitError c) = display (plain c)
 displayInteraction (KnitAsIs c) = display (plain c)
 displayInteraction (KnitImage cap img) = do
   let caption
-          | isBoringCaption cap = mempty
-          | otherwise = H.p (H.toMarkup cap)
+        | isBoringCaption cap = mempty
+        | otherwise = H.p (H.toMarkup cap)
   encoded <- Base64.encode <$> B.readFile img
-  display $ H.img H.! H.src (H.unsafeByteStringValue
-                         -- assumes you use the default device which is png
-                        (Char.pack "data:image/png;base64," <> encoded))
-              <> caption
+  display $ H.img H.! H.src
+                        (H.unsafeByteStringValue
+                           -- assumes you use the default device which is png
+                           (Char.pack "data:image/png;base64," <> encoded))
+            <> caption

ihaskell-display/ihaskell-static-canvas/src/IHaskell/Display/StaticCanvas.hs

@@ -23,10 +23,7 @@ getUniqueName = do
   putMVar uniqueCounter val'
   return $ pack $ "ihaskellStaticCanvasUniqueID" ++ show val
 
-data Canvas = Canvas { width :: Int
-                     , height :: Int
-                     , canvas :: CanvasFree ()
-                     }
+data Canvas = Canvas { width :: Int, height :: Int, canvas :: CanvasFree () }
 
 instance IHaskellDisplay Canvas where
   display cnv = do

ihaskell-display/ihaskell-widgets/IHaskell/Display/Widgets.hs

 {-# LANGUAGE NoImplicitPrelude, OverloadedStrings #-}
+
 module IHaskell.Display.Widgets () where
 
-import ClassyPrelude
+import           ClassyPrelude
 
-import Data.Aeson
+import           Data.Aeson
 
-import IHaskell.Widgets
-import IHaskell.Display
+import           IHaskell.Widgets
+import           IHaskell.Display
 
 data WidgetName = ButtonWidget
 
@@ -17,18 +18,19 @@ instance ToJSON WidgetName where
   toJSON ButtonWidget = "ButtonView"
 
 instance ToJSON WidgetMessage where
-  toJSON DisplayWidget = object [ "method" .= str "display" ]
-  toJSON (InitialState name) = object [
-                                  "method" .= str "update",
-                                  "state" .= object [
-                                    "_view_name" .= name,
-                                    "visible" .= True,
-                                    "_css" .= object [],
-                                    "msg_throttle" .= (3 :: Int),
-                                    "disabled" .= False,
-                                    "description" .= str "Button"
-                                  ]
-                                ]
+  toJSON DisplayWidget = object ["method" .= str "display"]
+  toJSON (InitialState name) = object
+                                 [ "method" .= str "update"
+                                 , "state" .= object
+                                                [ "_view_name" .= name
+                                                , "visible" .= True
+                                                , "_css" .= object []
+                                                , "msg_throttle" .= (3 :: Int)
+                                                , "disabled" .= False
+                                                , "description" .= str "Button"
+                                                ]
+                                 ]
+
 str :: String -> String
 str = id
 
@@ -40,12 +42,11 @@ data ParseText = ParseText String
 
 instance FromJSON ParseText where
   parseJSON (Object v) = ParseText <$> v .: "text"
-  parseJSON _          = fail "Expecting object"
+  parseJSON _ = fail "Expecting object"
 
 instance IHaskellWidget Slider where
   -- Name for this widget.
   targetName _ = "WidgetModel"
-
   -- Start by sending messages to set up the widget.
   open widget send = do
     putStrLn "Sending widgets!"

ihaskell-display/ihaskell-widgets/IHaskell/Widgets.hs

-module IHaskell.Widgets (
-  Slider(..)
-  ) where
+module IHaskell.Widgets (Slider(..)) where
 
 data Slider = Slider

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

--- | This module exports all the types and functions necessary to create an
--- IPython language kernel that supports the @ipython console@ and @ipython
--- notebook@ frontends. 
-module IHaskell.IPython.Kernel (
-  module X,
-  ) where
+-- | This module exports all the types and functions necessary to create an IPython language kernel
+-- that supports the @ipython console@ and @ipython notebook@ frontends.
+module IHaskell.IPython.Kernel (module X) where
 
-import IHaskell.IPython.Types as X
-import IHaskell.IPython.Message.Writer as X
-import IHaskell.IPython.Message.Parser as X
-import IHaskell.IPython.Message.UUID as X
-import IHaskell.IPython.ZeroMQ as X
+import           IHaskell.IPython.Types as X
+import           IHaskell.IPython.Message.Writer as X
+import           IHaskell.IPython.Message.Parser as X
+import           IHaskell.IPython.Message.UUID as X
+import           IHaskell.IPython.ZeroMQ as X

ipython-kernel/src/IHaskell/IPython/Message/Parser.hs

 {-# LANGUAGE OverloadedStrings #-}
+
 -- | Description : Parsing messages received from IPython
 --
--- This module is responsible for converting from low-level ByteStrings
--- obtained from the 0MQ sockets into Messages. The only exposed function is
--- `parseMessage`, which should only be used in the low-level 0MQ interface.
+-- This module is responsible for converting from low-level ByteStrings obtained from the 0MQ
+-- sockets into Messages. The only exposed function is `parseMessage`, which should only be used in
+-- the low-level 0MQ interface.
 module IHaskell.IPython.Message.Parser (parseMessage) where
 
 import           Data.Aeson ((.:), decode, Result(..), Object)
@@ -17,9 +18,7 @@ import           IHaskell.IPython.Types
 
 type LByteString = Lazy.ByteString
 
------ External interface -----
-
--- | Parse a message from its ByteString components into a Message.
+-- --- External interface ----- | Parse a message from its ByteString components into a Message.
 parseMessage :: [ByteString] -- ^ The list of identifiers sent with the message.
              -> ByteString   -- ^ The header data.
              -> ByteString   -- ^ The parent header, which is just "{}" if there is no header.
@@ -32,26 +31,25 @@ parseMessage idents headerData parentHeader metadata content =
       messageWithoutHeader = parser messageType $ Lazy.fromStrict content
   in messageWithoutHeader { header = header }
 
------ Module internals -----
-
--- | Parse a header from its ByteString components into a MessageHeader.
+-- --- Module internals ----- | Parse a header from its ByteString components into a MessageHeader.
 parseHeader :: [ByteString]  -- ^ The list of identifiers.
             -> ByteString    -- ^ The header data.
             -> ByteString    -- ^ The parent header, or "{}" for Nothing.
             -> ByteString    -- ^ The metadata, or "{}" for an empty map.
             -> MessageHeader -- The resulting message header.
 parseHeader idents headerData parentHeader metadata =
-  MessageHeader { identifiers = idents
-                , parentHeader = parentResult
-                , metadata = metadataMap
-                , messageId = messageUUID
-                , sessionId = sessionUUID
-                , username = username
-                , msgType = messageType
-                }
+  MessageHeader
+    { identifiers = idents
+    , parentHeader = parentResult
+    , metadata = metadataMap
+    , messageId = messageUUID
+    , sessionId = sessionUUID
+    , username = username
+    , msgType = messageType
+    }
   where
-    -- Decode the header data and the parent header data into JSON objects.
-    -- If the parent header data is absent, just have Nothing instead.
+    -- Decode the header data and the parent header data into JSON objects. If the parent header data is
+    -- absent, just have Nothing instead.
     Just result = decode $ Lazy.fromStrict headerData :: Maybe Object
     parentResult = if parentHeader == "{}"
                      then Nothing
@@ -71,27 +69,26 @@ noHeader :: MessageHeader
 noHeader = error "No header created"
 
 parser :: MessageType            -- ^ The message type being parsed.
-       -> LByteString -> Message -- ^ The parser that converts the body into a message.
-                                 -- This message should have an undefined header.
+       -> LByteString -> Message -- ^ The parser that converts the body into a message. This message
+                                 -- should have an undefined header.
 parser KernelInfoRequestMessage = kernelInfoRequestParser
-parser ExecuteRequestMessage    = executeRequestParser
-parser CompleteRequestMessage   = completeRequestParser
+parser ExecuteRequestMessage = executeRequestParser
+parser CompleteRequestMessage = completeRequestParser
 parser ObjectInfoRequestMessage = objectInfoRequestParser
-parser ShutdownRequestMessage   = shutdownRequestParser
-parser InputReplyMessage        = inputReplyParser
-parser CommOpenMessage          = commOpenParser
-parser CommDataMessage          = commDataParser
-parser CommCloseMessage         = commCloseParser
-parser HistoryRequestMessage    = historyRequestParser
-parser other                    = error $ "Unknown message type " ++ show other
-
--- | Parse a kernel info request.
--- A kernel info request has no auxiliary information, so ignore the body.
+parser ShutdownRequestMessage = shutdownRequestParser
+parser InputReplyMessage = inputReplyParser
+parser CommOpenMessage = commOpenParser
+parser CommDataMessage = commDataParser
+parser CommCloseMessage = commCloseParser
+parser HistoryRequestMessage = historyRequestParser
+parser other = error $ "Unknown message type " ++ show other
+
+-- | Parse a kernel info request. A kernel info request has no auxiliary information, so ignore the
+-- body.
 kernelInfoRequestParser :: LByteString -> Message
 kernelInfoRequestParser _ = KernelInfoRequest { header = noHeader }
 
--- | Parse an execute request.
--- Fields used are:
+-- | Parse an execute request. Fields used are:
 --  1. "code": the code to execute.
 --  2. "silent": whether to execute silently.
 --  3. "store_history": whether to include this in history.
@@ -99,22 +96,23 @@ kernelInfoRequestParser _ = KernelInfoRequest { header = noHeader }
 executeRequestParser :: LByteString -> Message
 executeRequestParser content =
   let parser obj = do
-        code <- obj .: "code"
-        silent <- obj .: "silent"
-        storeHistory <- obj .: "store_history"
-        allowStdin <- obj .: "allow_stdin"
+                     code <- obj .: "code"
+                     silent <- obj .: "silent"
+                     storeHistory <- obj .: "store_history"
+                     allowStdin <- obj .: "allow_stdin"
 
-        return (code, silent, storeHistory, allowStdin)
+                     return (code, silent, storeHistory, allowStdin)
       Just decoded = decode content
       Success (code, silent, storeHistory, allowStdin) = parse parser decoded
-  in ExecuteRequest { header = noHeader
-                    , getCode = code
-                    , getSilent = silent
-                    , getAllowStdin = allowStdin
-                    , getStoreHistory = storeHistory
-                    , getUserVariables = []
-                    , getUserExpressions = []
-                    }
+  in ExecuteRequest
+    { header = noHeader
+    , getCode = code
+    , getSilent = silent
+    , getAllowStdin = allowStdin
+    , getStoreHistory = storeHistory
+    , getUserVariables = []
+    , getUserExpressions = []
+    }
 
 requestParser parser content = parsed
   where
@@ -147,7 +145,6 @@ objectInfoRequestParser = requestParser $ \obj -> do
   dlevel <- obj .: "detail_level"
   return $ ObjectInfoRequest noHeader oname dlevel
 
-
 shutdownRequestParser :: LByteString -> Message
 shutdownRequestParser = requestParser $ \obj -> do
   code <- obj .: "restart"

ipython-kernel/src/IHaskell/IPython/Message/UUID.hs

 -- | Description : UUID generator and data structure
 --
 -- Generate, parse, and pretty print UUIDs for use with IPython.
-module IHaskell.IPython.Message.UUID (
-  UUID,
-  random, randoms,
-  ) where
+module IHaskell.IPython.Message.UUID (UUID, random, randoms) where
 
-import Control.Monad (mzero, replicateM)
-import Control.Applicative ((<$>))
-import Data.Text (pack)
-import Data.Aeson
-import Data.UUID.V4 (nextRandom)
-
--- We use an internal string representation because for the purposes of
--- IPython, it matters whether the letters are uppercase or lowercase and
--- whether the dashes are present in the correct locations. For the
--- purposes of new UUIDs, it does not matter, but IPython expects UUIDs
--- passed to kernels to be returned unchanged, so we cannot actually parse
--- them.
+import           Control.Monad (mzero, replicateM)
+import           Control.Applicative ((<$>))
+import           Data.Text (pack)
+import           Data.Aeson
+import           Data.UUID.V4 (nextRandom)
 
 -- | A UUID (universally unique identifier).
-data UUID = UUID String deriving (Show, Read, Eq, Ord)
+data UUID =
+     -- We use an internal string representation because for the purposes of IPython, it
+     -- matters whether the letters are uppercase or lowercase and whether the dashes are
+     -- present in the correct locations. For the purposes of new UUIDs, it does not matter,
+     -- but IPython expects UUIDs passed to kernels to be returned unchanged, so we cannot
+     -- actually parse them.
+      UUID String
+  deriving (Show, Read, Eq, Ord)
 
 -- | Generate a list of random UUIDs.
 randoms :: Int      -- ^ Number of UUIDs to generate.

ipython-kernel/src/IHaskell/IPython/Message/Writer.hs

 {-# LANGUAGE OverloadedStrings #-}
+
 -- | Description : @ToJSON@ for Messages
 --
 -- This module contains the @ToJSON@ instance for @Message@.
-module IHaskell.IPython.Message.Writer (
-  ToJSON(..)
-)  where
+module IHaskell.IPython.Message.Writer (ToJSON(..)) where
 
-import Data.Aeson
-import Data.Map     (Map)
-import Data.Text    (Text, pack)
-import Data.Monoid  (mempty)
+import           Data.Aeson
+import           Data.Map (Map)
+import           Data.Text (Text, pack)
+import           Data.Monoid (mempty)
 
 import qualified Data.ByteString.Lazy as L
 import qualified Data.ByteString as B
-import Data.Text.Encoding
+import           Data.Text.Encoding
 
-import IHaskell.IPython.Types
+import           IHaskell.IPython.Types
 
 -- Convert message bodies into JSON.
 instance ToJSON Message where
-  toJSON KernelInfoReply{ versionList = vers, language = language } = object [
-                             "protocol_version" .= string "5.0", -- current protocol version, major and minor
-                             "language_version" .= vers,
-                             "language" .= language
-                           ]
-
-  toJSON ExecuteReply{ status = status, executionCounter = counter, pagerOutput = pager} = object [
-                             "status" .= show status,
-                             "execution_count" .= counter,
-                             "payload" .= 
-                               if null pager
-                               then []
-                               else [object [
-                                    "source" .= string "page",
-                                    "text" .= pager
-                                ]],
-                             "user_variables" .= emptyMap,
-                             "user_expressions" .= emptyMap
-                           ]
-  toJSON PublishStatus{ executionState = executionState } = object [
-                             "execution_state" .= executionState
-                           ]
-  toJSON PublishStream{ streamType = streamType, streamContent = content } = object [
-                             "data" .= content,
-                             "name" .= streamType
-                           ]
-  toJSON PublishDisplayData{ source = src, displayData = datas } = object [
-                             "source" .= src,
-                             "metadata" .= object [],
-                             "data" .= object  (map displayDataToJson datas)
-                           ]
-
-  toJSON PublishOutput{ executionCount = execCount, reprText = reprText } = object [
-                             "data" .= object ["text/plain" .= reprText],
-                             "execution_count" .= execCount,
-                             "metadata" .= object []
-                           ]
-  toJSON PublishInput{ executionCount = execCount, inCode = code } = object [
-                             "execution_count" .= execCount,
-                             "code" .= code
-                           ]
-  toJSON (CompleteReply _ matches start end metadata status) = object [
-                             "matches" .= matches,
-                             "cursor_start" .= start,
-                             "cursor_end" .= end,
-                             "metadata" .= metadata,
-                             "status" .= if status then string "ok" else "error"
-                           ]
-  toJSON o@ObjectInfoReply{} = object [
-                            "oname" .= objectName o,
-                            "found" .= objectFound o,
-                            "ismagic" .= False,
-                            "isalias" .= False,
-                            "type_name" .= objectTypeString o,
-                            "docstring" .= objectDocString o
-                           ]
-
-  toJSON ShutdownReply{restartPending = restart} = object [
-                            "restart" .= restart
-                           ]
-
-  toJSON ClearOutput{wait = wait} = object [
-                            "wait" .= wait
-                           ]
-
-  toJSON RequestInput{inputPrompt = prompt} = object [
-                            "prompt" .= prompt
-                           ]
-
-  toJSON req@CommOpen{} = object [
-                            "comm_id" .= commUuid req,
-                            "target_name" .= commTargetName req,
-                            "data" .= commData req
-                           ]
-
-  toJSON req@CommData{} = object [
-                            "comm_id" .= commUuid req,
-                            "data" .= commData req
-                           ]
-
-  toJSON req@CommClose{} = object [
-                            "comm_id" .= commUuid req,
-                            "data" .= commData req
-                           ]
-
-  toJSON req@HistoryReply{} = object [ "history" .= map tuplify (historyReply req) ]
-    where tuplify (HistoryReplyElement sess linum res) = (sess, linum, case res of 
-            Left inp -> toJSON inp
-            Right (inp, out) -> toJSON out)
+  toJSON KernelInfoReply { versionList = vers, language = language } =
+    object ["protocol_version" .= string "5.0"  -- current protocol version, major and minor
+           , "language_version" .= vers, "language" .= language]
+
+  toJSON ExecuteReply { status = status, executionCounter = counter, pagerOutput = pager } =
+    object
+      [ "status" .= show status
+      , "execution_count" .= counter
+      , "payload" .=
+        if null pager
+          then []
+          else [object ["source" .= string "page", "text" .= pager]]
+      , "user_variables" .= emptyMap
+      , "user_expressions" .= emptyMap
+      ]
+  toJSON PublishStatus { executionState = executionState } =
+    object ["execution_state" .= executionState]
+  toJSON PublishStream { streamType = streamType, streamContent = content } =
+    object ["data" .= content, "name" .= streamType]
+  toJSON PublishDisplayData { source = src, displayData = datas } =
+    object
+      ["source" .= src, "metadata" .=
+                        object [], "data" .=
+                                   object (map displayDataToJson datas)]
+
+  toJSON PublishOutput { executionCount = execCount, reprText = reprText } =
+    object
+      ["data" .=
+       object ["text/plain" .= reprText], "execution_count" .= execCount, "metadata" .=
+                                                                          object []]
+  toJSON PublishInput { executionCount = execCount, inCode = code } =
+    object ["execution_count" .= execCount, "code" .= code]
+  toJSON (CompleteReply _ matches start end metadata status) =
+    object
+      [ "matches" .= matches
+      , "cursor_start" .= start
+      , "cursor_end" .= end
+      , "metadata" .= metadata
+      , "status" .= if status
+                      then string "ok"
+                      else "error"
+      ]
+  toJSON o@ObjectInfoReply{} =
+    object
+      [ "oname" .=
+        objectName o
+      , "found" .= objectFound o
+      , "ismagic" .= False
+      , "isalias" .= False
+      , "type_name" .= objectTypeString o
+      , "docstring" .= objectDocString o
+      ]
+
+  toJSON ShutdownReply { restartPending = restart } =
+    object ["restart" .= restart]
+
+  toJSON ClearOutput { wait = wait } =
+    object ["wait" .= wait]
+
+  toJSON RequestInput { inputPrompt = prompt } =
+    object ["prompt" .= prompt]
+
+  toJSON req@CommOpen{} =
+    object ["comm_id" .= commUuid req, "target_name" .= commTargetName req, "data" .= commData req]
+
+  toJSON req@CommData{} =
+    object ["comm_id" .= commUuid req, "data" .= commData req]
+
+  toJSON req@CommClose{} =
+    object ["comm_id" .= commUuid req, "data" .= commData req]
+
+  toJSON req@HistoryReply{} =
+    object ["history" .= map tuplify (historyReply req)]
+    where
+      tuplify (HistoryReplyElement sess linum res) = (sess, linum, case res of
+                                                                     Left inp         -> toJSON inp
+                                                                     Right (inp, out) -> toJSON out)
 
   toJSON body = error $ "Do not know how to convert to JSON for message " ++ show body
 
-
 -- | Print an execution state as "busy", "idle", or "starting".
 instance ToJSON ExecutionState where
-    toJSON Busy = String "busy"
-    toJSON Idle = String "idle"
-    toJSON Starting = String "starting"
+  toJSON Busy = String "busy"
+  toJSON Idle = String "idle"
+  toJSON Starting = String "starting"
 
 -- | Print a stream as "stdin" or "stdout" strings.
 instance ToJSON StreamType where
-    toJSON Stdin = String "stdin"
-    toJSON Stdout = String "stdout"
+  toJSON Stdin = String "stdin"
+  toJSON Stdout = String "stdout"
 
 -- | Convert a MIME type and value into a JSON dictionary pair.
-displayDataToJson :: DisplayData -> (Text, Value) 
+displayDataToJson :: DisplayData -> (Text, Value)
 displayDataToJson (DisplayData mimeType dataStr) =
-    pack (show mimeType) .= String dataStr
+  pack (show mimeType) .= String dataStr
 
 ----- Constants -----
-
 emptyMap :: Map String String
 emptyMap = mempty
 

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

 {-# LANGUAGE OverloadedStrings, DoAndIfThenElse #-}
--- | This module provides a way in which the Haskell standard input may be
--- forwarded to the IPython frontend and thus allows the notebook to use
--- the standard input.
+
+-- | This module provides a way in which the Haskell standard input may be forwarded to the IPython
+-- frontend and thus allows the notebook to use the standard input.
 --
--- This relies on the implementation of file handles in GHC, and is
--- generally unsafe and terrible. However, it is difficult to find another
--- way to do it, as file handles are generally meant to point to streams
--- and files, and not networked communication protocols.
+-- This relies on the implementation of file handles in GHC, and is generally unsafe and terrible.
+-- However, it is difficult to find another way to do it, as file handles are generally meant to
+-- point to streams and files, and not networked communication protocols.
 --
--- In order to use this module, it must first be initialized with two
--- things. First of all, in order to know how to communicate with the
--- IPython frontend, it must know the kernel profile used for
--- communication. For this, use @recordKernelProfile@ once the profile is
--- known. Both this and @recordParentHeader@ take a directory name where
--- they can store this data.
+-- In order to use this module, it must first be initialized with two things. First of all, in order
+-- to know how to communicate with the IPython frontend, it must know the kernel profile used for
+-- communication. For this, use @recordKernelProfile@ once the profile is known. Both this and
+-- @recordParentHeader@ take a directory name where they can store this data.
 --
--- Finally, the module must know what @execute_request@ message is
--- currently being replied to (which will request the input). Thus, every
--- time the language kernel receives an @execute_request@ message, it
--- should inform this module via @recordParentHeader@, so that the module
--- may generate messages with an appropriate parent header set. If this is
--- not done, the IPython frontends will not recognize the target of the
--- communication.
+-- Finally, the module must know what @execute_request@ message is currently being replied to (which
+-- will request the input). Thus, every time the language kernel receives an @execute_request@
+-- message, it should inform this module via @recordParentHeader@, so that the module may generate
+-- messages with an appropriate parent header set. If this is not done, the IPython frontends will
+-- not recognize the target of the communication.
 --
--- Finally, in order to activate this module, @fixStdin@ must be called
--- once. It must be passed the same directory name as @recordParentHeader@
--- and @recordKernelProfile@. Note that if this is being used from within
--- the GHC API, @fixStdin@ /must/ be called from within the GHC session
--- not from the host code.
-module IHaskell.IPython.Stdin (
-  fixStdin,
-  recordParentHeader,
-  recordKernelProfile
-  ) where
+-- Finally, in order to activate this module, @fixStdin@ must be called once. It must be passed the
+-- same directory name as @recordParentHeader@ and @recordKernelProfile@. Note that if this is being
+-- used from within the GHC API, @fixStdin@ /must/ be called from within the GHC session not from
+-- the host code.
+module IHaskell.IPython.Stdin (fixStdin, recordParentHeader, recordKernelProfile) where
 
-import            Control.Concurrent          
-import            Control.Applicative         ((<$>))
-import            Control.Concurrent.Chan
-import            Control.Monad
-import            GHC.IO.Handle
-import            GHC.IO.Handle.Types
-import            System.IO
-import            System.Posix.IO
-import            System.IO.Unsafe
-import qualified  Data.Map                    as Map
+import           Control.Concurrent
+import           Control.Applicative ((<$>))
+import           Control.Concurrent.Chan
+import           Control.Monad
+import           GHC.IO.Handle
+import           GHC.IO.Handle.Types
+import           System.IO
+import           System.Posix.IO
+import           System.IO.Unsafe
+import qualified Data.Map as Map
 
-import            IHaskell.IPython.Types
-import            IHaskell.IPython.ZeroMQ
-import            IHaskell.IPython.Message.UUID       as UUID
+import           IHaskell.IPython.Types
+import           IHaskell.IPython.ZeroMQ
+import           IHaskell.IPython.Message.UUID as UUID
 
 stdinInterface :: MVar ZeroMQStdin
 {-# NOINLINE stdinInterface #-}
 stdinInterface = unsafePerformIO newEmptyMVar
 
--- | Manipulate standard input so that it is sourced from the IPython
--- frontend. This function is build on layers of deep magical hackery, so
--- be careful modifying it.
+-- | Manipulate standard input so that it is sourced from the IPython frontend. This function is
+-- build on layers of deep magical hackery, so be careful modifying it.
 fixStdin :: String -> IO ()
 fixStdin dir = do
   -- Initialize the stdin interface.
@@ -78,17 +67,18 @@ stdinOnce dir = do
   hDuplicateTo newStdin stdin
 
   loop stdinInput oldStdin newStdin
+
   where
     loop stdinInput oldStdin newStdin = do
       let FileHandle _ mvar = stdin
       threadDelay $ 150 * 1000
       empty <- isEmptyMVar mvar
       if not empty
-      then loop stdinInput oldStdin newStdin
-      else do
-        line <- getInputLine dir
-        hPutStr stdinInput $ line ++ "\n"
-        loop stdinInput oldStdin newStdin
+        then loop stdinInput oldStdin newStdin
+        else do
+          line <- getInputLine dir
+          hPutStr stdinInput $ line ++ "\n"
+          loop stdinInput oldStdin newStdin
 
 -- | Get a line of input from the IPython frontend.
 getInputLine :: String -> IO String
@@ -98,15 +88,15 @@ getInputLine dir = do
   -- Send a request for input.
   uuid <- UUID.random
   parentHeader <- read <$> readFile (dir ++ "/.last-req-header")
-  let header = MessageHeader {
-      username = username parentHeader,
-      identifiers = identifiers parentHeader,
-      parentHeader = Just parentHeader,
-      messageId = uuid,
-      sessionId = sessionId parentHeader,
-      metadata = Map.fromList [],
-      msgType = InputRequestMessage
-    }
+  let header = MessageHeader
+        { username = username parentHeader
+        , identifiers = identifiers parentHeader
+        , parentHeader = Just parentHeader
+        , messageId = uuid
+        , sessionId = sessionId parentHeader
+        , metadata = Map.fromList []
+        , msgType = InputRequestMessage
+        }
   let msg = RequestInput header ""
   writeChan req msg
 

verify_formatting.py

@@ -44,10 +44,16 @@ except:
 
 # Find all the source files
 sources = []
-for root, dirnames, filenames in os.walk("src"):
-    for filename in filenames:
-        if filename.endswith(".hs"):
-            sources.append(os.path.join(root, filename))
+for source_dir in ["src", "ipython-kernel", "ihaskell-display"]:
+    for root, dirnames, filenames in os.walk(source_dir):
+        # Skip cabal dist directories
+        if "dist" in root:
+            continue
+
+        for filename in filenames:
+            # Take Haskell files, but ignore the Cabal Setup.hs
+            if filename.endswith(".hs") and filename != "Setup.hs":
+                sources.append(os.path.join(root, filename))
 
 
 hindent_outputs = {}