changing DisplayData -> Display in IHaskell

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

@@ -10,7 +10,7 @@ import Data.String.Here
 import IHaskell.Display
 
 instance IHaskellDisplay Value where
-  display renderable = return [plain json, html dom]
+  display renderable = return $ Display [plain json, html dom]
     where 
       json = unpack $ decodeUtf8 $ encodePretty renderable
       dom = [i|<div class="highlight-code" id="javascript">${json}</div>|]

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

@@ -6,7 +6,7 @@ import IHaskell.Display
 import Text.Printf
 
 instance Show a => IHaskellDisplay (Maybe a) where
-  display just = return [stringDisplay, htmlDisplay]
+  display just = return $ Display [stringDisplay, htmlDisplay]
     where 
       stringDisplay = plain (show just)
       htmlDisplay = html str

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

@@ -10,7 +10,7 @@ import Text.Blaze.Internal
 import Control.Monad
 
 instance IHaskellDisplay (MarkupM a) where
-  display val = return [stringDisplay, htmlDisplay]
+  display val = return $ Display [stringDisplay, htmlDisplay]
     where 
       str = renderMarkup (void val)
       stringDisplay = plain str

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

@@ -26,7 +26,7 @@ instance IHaskellDisplay (Renderable a) where
     -- but SVGs are not resizable in the IPython notebook.
     svgDisp <- chartData renderable SVG
 
-    return [pngDisp, svgDisp]
+    return $ Display [pngDisp, svgDisp]
 
 chartData :: Renderable a -> FileFormat -> IO DisplayData
 chartData renderable format = do

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

@@ -16,7 +16,7 @@ instance IHaskellDisplay (Diagram Cairo R2) where
   display renderable = do
     png <- diagramData renderable PNG
     svg <- diagramData renderable SVG
-    return [png, svg]
+    return $ Display [png, svg]
 
 diagramData :: Diagram Cairo R2 -> OutputType -> IO DisplayData
 diagramData renderable format = do

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

@@ -24,7 +24,7 @@ instance IHaskellDisplay B.ByteString where
         m <- magicOpen []
         magicLoadDefault m
         f <- B.unsafeUseAsCStringLen x (magicCString m)
-        return [withClass (parseMagic f) x]
+        return $ Display [withClass (parseMagic f) x]
 
 b64 :: B.ByteString -> String
 b64 = Char.unpack . Base64.encode

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

@@ -101,7 +101,7 @@ instance ToJSON StreamType where
 
 -- | Convert a MIME type and value into a JSON dictionary pair.
 displayDataToJson :: DisplayData -> (Text, Value) 
-displayDataToJson (Display mimeType dataStr) = pack (show mimeType) .= dataStr
+displayDataToJson (DisplayData mimeType dataStr) = pack (show mimeType) .= dataStr
 
 ----- Constants -----
 

ipython-kernel/src/IPython/Types.hs

@@ -341,13 +341,13 @@ replyType ShutdownRequestMessage    = Just ShutdownReplyMessage
 replyType _ = Nothing
 
 -- | Data for display: a string with associated MIME type.
-data DisplayData = Display MimeType ByteString deriving (Typeable, Generic)
+data DisplayData = DisplayData MimeType ByteString deriving (Typeable, Generic)
 
 -- We can't print the actual data, otherwise this will be printed every
 -- time it gets computed because of the way the evaluator is structured.
 -- See how `displayExpr` is computed.
 instance Show DisplayData where
-  show _ = "Display"
+  show _ = "DisplayData"
 
 -- Allow DisplayData serialization
 instance Serialize DisplayData
@@ -369,9 +369,9 @@ extractPlain :: [DisplayData] -> String
 extractPlain disps =
   case find isPlain disps of
     Nothing -> ""
-    Just (Display PlainText bytestr) -> Char.unpack bytestr
+    Just (DisplayData PlainText bytestr) -> Char.unpack bytestr
   where
-    isPlain (Display mime _) = mime == PlainText
+    isPlain (DisplayData mime _) = mime == PlainText
 
 instance Show MimeType where
   show PlainText = "text/plain"

src/IHaskell/Display.hs

@@ -5,12 +5,13 @@ module IHaskell.Display (
   serializeDisplay,
   Width, Height, Base64,
   encode64, base64,
-  DisplayData
+  Display(..),
+  DisplayData(..),
   ) where
 
 import ClassyPrelude
 import Data.Serialize as Serialize
-import Data.ByteString
+import Data.ByteString hiding (map)
 import Data.String.Utils (rstrip) 
 import qualified Data.ByteString.Base64 as Base64
 import qualified Data.ByteString.Char8 as Char
@@ -27,52 +28,59 @@ type Base64 = ByteString
 -- > instance (Show a) => IHaskellDisplay a
 -- > instance Show a where shows _ = id
 class IHaskellDisplay a where
-  display :: a -> IO [DisplayData]
+  display :: a -> IO Display
 
 -- | these instances cause the image, html etc. which look like:
 --
--- > DisplayData
--- > [DisplayData]
--- > IO [DisplayData]
--- > IO (IO DisplayData)
+-- > Display
+-- > [Display]
+-- > IO [Display]
+-- > IO (IO Display)
 --
 -- be run the IO and get rendered (if the frontend allows it) in the pretty
 -- form.
 instance IHaskellDisplay a => IHaskellDisplay (IO a) where
-        display = (display =<<)
-instance IHaskellDisplay DisplayData where
-  display disp = return [disp]
+  display = (display =<<)
 
-instance IHaskellDisplay [DisplayData] where
+instance IHaskellDisplay Display where
   display = return
 
+instance IHaskellDisplay a => IHaskellDisplay [a] where
+  display disps = do
+    displays <- mapM display disps
+    return $ ManyDisplay displays
+
+-- | Encode many displays into a single one. All will be output.
+many :: [Display] -> Display
+many = ManyDisplay
+
 -- | Generate a plain text display.
 plain :: String -> DisplayData
-plain = Display PlainText . Char.pack . rstrip
+plain = DisplayData PlainText . Char.pack . rstrip
 
 -- | Generate an HTML display.
 html :: String -> DisplayData
-html = Display MimeHtml . Char.pack
+html = DisplayData MimeHtml . Char.pack
 
 -- | Genreate an SVG display.
 svg :: String -> DisplayData
-svg = Display MimeSvg . Char.pack
+svg = DisplayData MimeSvg . Char.pack
 
 -- | Genreate a LaTeX display.
 latex :: String -> DisplayData
-latex = Display MimeLatex . Char.pack
+latex = DisplayData MimeLatex . Char.pack
 
 -- | Generate a PNG display of the given width and height. Data must be
 -- provided in a Base64 encoded manner, suitable for embedding into HTML.
 -- The @base64@ function may be used to encode data into this format.
 png :: Width -> Height -> Base64 -> DisplayData
-png width height = Display (MimePng width height)
+png width height = DisplayData (MimePng width height)
 
 -- | Generate a JPG display of the given width and height. Data must be
 -- provided in a Base64 encoded manner, suitable for embedding into HTML.
 -- The @base64@ function may be used to encode data into this format.
 jpg :: Width -> Height -> Base64 -> DisplayData
-jpg width height = Display (MimeJpg width height)
+jpg width height = DisplayData (MimeJpg width height)
 
 -- | Convert from a string into base 64 encoded data.
 encode64 :: String -> Base64
@@ -84,5 +92,5 @@ base64 = Base64.encode
 
 -- | For internal use within IHaskell.
 -- Serialize displays to a ByteString.
-serializeDisplay :: [DisplayData] -> ByteString
+serializeDisplay :: Display -> ByteString
 serializeDisplay = Serialize.encode

src/IHaskell/Eval/Lint.hs

@@ -38,7 +38,7 @@ lintIdent = "lintIdentAEjlkQeh"
 
 -- | Given parsed code chunks, perform linting and output a displayable
 -- report on linting warnings and errors.
-lint :: [Located CodeBlock] -> IO [DisplayData]
+lint :: [Located CodeBlock] -> IO Display
 lint blocks = do
   let validBlocks = map makeValid blocks
       fileContents = joinBlocks validBlocks
@@ -50,8 +50,8 @@ lint blocks = do
   suggestions <- catMaybes <$> map parseSuggestion <$> hlint [filename, "--quiet"]
   return $
     if null suggestions
-    then []
-    else
+    then Display []
+    else Display
       [plain $ concatMap plainSuggestion suggestions, html $ htmlSuggestions suggestions]
   where
     -- Join together multiple valid file blocks into a single file.

src/IHaskell/Types.hs

@@ -20,12 +20,15 @@ module IHaskell.Types (
   Width, Height,
   FrontendType(..),
   ViewFormat(..),
+  Display(..),
   defaultKernelState,
   extractPlain
   ) where
 
 import            ClassyPrelude
 import qualified  Data.ByteString.Char8           as Char
+import            Data.Serialize
+import            GHC.Generics
 
 import            Text.Read                       as Read hiding (pfail, String)
 import            Text.ParserCombinators.ReadP
@@ -60,6 +63,12 @@ instance Read ViewFormat where
       "md" -> return Markdown
       _ -> pfail
 
+-- | Wrapper for ipython-kernel's DisplayData which allows sending multiple
+-- results from the same expression.
+data Display = Display [DisplayData]
+             | ManyDisplay [Display]
+             deriving (Show, Typeable, Generic)
+instance Serialize Display
 
 -- | All state stored in the kernel between executions.
 data KernelState = KernelState
@@ -108,9 +117,9 @@ data EvaluationResult =
   -- | An intermediate result which communicates what has been printed thus
   -- far.
   IntermediateResult {
-    outputs :: [DisplayData]      -- ^ Display outputs.
+    outputs :: Display      -- ^ Display outputs.
   }
   | FinalResult {
-    outputs :: [DisplayData],     -- ^ Display outputs.
+    outputs :: Display,     -- ^ Display outputs.
     pagerOut :: String            -- ^ Text to display in the IPython pager.
   }

src/Main.hs

@@ -252,7 +252,8 @@ replyTo interface req@ExecuteRequest{ getCode = code } replyHeader state = do
         header <- dupHeader replyHeader ClearOutputMessage
         send $ ClearOutput header True
 
-      sendOutput outs = do
+      sendOutput (ManyDisplay manyOuts) = mapM_ sendOutput manyOuts
+      sendOutput (Display outs) = do
         header <- dupHeader replyHeader DisplayDataMessage
         send $ PublishDisplayData header "haskell" outs