Dco      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _ ` abcdefghijklmn Safe-Inferred o pqrst    o pqrst "UUID generator and data structure None(A UUID (universally unique identifier). !Generate a list of random UUIDs. Generate a single random UUID. uNumber of UUIDs to generate. vwuvwNone>*Possible MIME types for the display data. 6Data for display: a string with associated MIME type. "Input and output streams. %#The execution state of the kernel. )3Possible statuses in the execution reply messages. -9A message used to communicate with the IPython frontend. :6Whether to wait to redraw until there is more output. =*Whether this shutdown precedes a restart. *Whether this shutdown precedes a restart. ?Whether the object was found. @ Object type. C'Name of object which was searched for. #Name of object being searched for. D)Level of detail desired (defaults to 0). * 0 is equivalent to foo?, 1 is equivalent  to foo??. K*just the line with the cursor. json field line L:position of the cursor (index into the line?). json field  cursor_pos NSubmitted input code. PPrinted output text. QWhich input this is. Which output this is for. SThe name of the data source. T A list of data representations. VWhich stream to publish to. WWhat to publish. Y#The execution state of the kernel. ZA reply to an execute request. [The status of the output. \&The help string to show in the pager. ]0The execution count, i.e. which output this is. ^0A request from a frontend to execute some code. _GThe entire block of text where the line is. This may be useful in the V case of multiline completions where more context may be needed. Note: if P in practice this field proves unnecessary, remove it to lighten the ! messages. json field block The code string. `*Whether this should be silently executed. a"Whether to store this in history. b!Whether this code can use stdin. cUnused. dUnused. e#A response to a KernelInfoRequest. f*The version of the language, e.g. [7, 6, 3] for GHC 7.6.3 gThe language name, e.g. haskell h<A request from a frontend for information about the kernel. j?The type of a message, corresponding to IPython message types. A metadata dictionary. (A username for the source of a message. 'A message header with some metadata. 'The identifiers sent with the message. The parent header, if present. A dict of metadata. A unique message UUID. A unique session UUID.  The user who sent this message. The message type. :A kernel profile, specifying how the kernel communicates. The IP on which to listen. The transport mechanism. The stdin channel port. The control channel port. The heartbeat channel port. The shell command port. The IOPub port. The HMAC encryption key. GThe transport mechanism used to communicate with the IPython frontend. %Default transport mechanism via TCP. An IP address.  A TCP port. 7Get the reply message type for a request message type.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~xyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-he^ZXUROMJEB><;97510/.iifgi_`abcdi[\]iYiVWiSTiPQiNQi_KLiFGHIiCDiC?@Ai=i=i:i8i6i234i34i34j~}|{zyxwvutsrqponmlk"$#%('&),+* ! !"$#%('&),+*-Xhe^ZXUROMJEB><;97510/.iifgi_`abcdi[\]iYiVWiSTiPQiNQi_KLiFGHIiCDiC?@Ai=i=i:i8i6i234i34i34j~}|{zyxwvutsrqponmlk xyz{|}~ToJSON for Messages None;Convert a MIME type and value into a JSON dictionary pair. Print a stream as stdin or stdout strings. Print an execution state as busy, idle, or starting. 'Parsing messages received from IPython None?Parse a message from its ByteString components into a Message. DParse a header from its ByteString components into a MessageHeader. Parse a kernel info request. I A kernel info request has no auxiliary information, so ignore the body. 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.  4.  allow_stdin5: whether to allow reading from stdin for this code. /The list of identifiers sent with the message. The header data. !The parent header, which is just {} if there is no header. The metadata map, also {} for an empty map. The message content. A parsed message. The list of identifiers. The header data. The parent header, or {} for Nothing. The metadata, or {} for an empty map. The message type being parsed. (Low-level ZeroMQ communication wrapper. NoneKThe channel interface to the ZeroMQ sockets. All communication is done via N Messages, which are encoded and decoded into a lower level form before being E transmitted to IPython. These channels should functionally serve as A high-level sockets which speak Messages instead of ByteStrings. 5A channel populated with requests from the frontend. CWriting to this channel causes a reply to be sent to the frontend. :This channel is a duplicate of the shell request channel, , ^ though using a different backend socket. 8This channel is a duplicate of the shell reply channel, , ^ though using a different backend socket. @Writing to this channel sends an iopub message to the frontend. IStart responding on all ZeroMQ channels used to communicate with IPython K | via the provided profile. Return a set of channels which can be used to : | communicate with IPython in a more structured manner. EServe on a given socket in a separate thread. Bind the socket in the H | given context and then loop the provided action, which should listen , | on the socket and respond to any events. BListener on the heartbeat port. Echoes back any data it was sent. >Listener on the shell port. Reads messages and writes them to J | the shell request channel. For each message, reads a response from the L | shell reply channel of the interface and sends it back to the frontend. >Listener on the shell port. Reads messages and writes them to J | the shell request channel. For each message, reads a response from the L | shell reply channel of the interface and sends it back to the frontend. %Send messages via the iopub channel. @ | This reads messages from the ZeroMQ iopub interface channel / | and then writes the messages to the socket. +Receive and parse a message from a socket. ?Encode a message in the IPython ZeroMQ communication protocol , | and send it through the provided socket. DThe profile specifying which ports and transport mechanisms to use. 4The Message-channel based interface to the sockets.  None !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneAManipulate standard input so that it is sourced from the IPython H frontend. This function is build on layers of deep magical hackery, so  be careful modifying it. /Get a line of input from the IPython frontend.  NoneGet a list of broken packages. ( This function internally shells out to  `ghc-pkg`, and parses the output 1 in order to determine what packages are broken.  None +A extension flag that can be set or unset. @Find the extension that corresponds to a given flag. Create the  corresponding  via SetFlag or  UnsetFlag. # If no such extension exist, yield Nothing. #Set an extension and update flags.  Return Nothing2 on success. On failure, return an error message.  Set a list of flags, as per GHCi's `:set`.  This was adapted from GHC'"s InteractiveUI.hs (newDynFlags). & It returns a list of error messages.  Convert an 1 into a string. This is similar to the family of  < functions, but does not impose an arbitrary width limit on G the output (in terms of number of columns). Instead, it respsects the  $ field in the structure returned by , and , thus gives a configurable width of output. ;Initialize the GHC API. Run this as the first thing in the . " This initializes some dyn flags (ExtendedDefaultRules,  NoMonomorphismRestriction+), sets the target to interpreted, link in E memory, sets a reasonable output width, and potentially a few other G things. It should be invoked before other functions from this module. EWe also require that the sandbox PackageConf (if any) is passed here E as setSessionDynFlags will read the package database the first time ) (and only the first time) it is called. $Evaluate a single import statement. E If this import statement is importing a module which was previously  imported implicitly (such as Prelude) or if this module has a hiding - annotation, the previous import is removed. #Evaluate a series of declarations. : Return all names which were bound by these declarations. :Get the type of an expression and convert it to a string. A wrapper around getInfo-. Return info about each name in the string. NoneCDirective types. Each directive is associated with a string in the  directive code block. Get the kind of a type via ':kind'. 0Get documentation for an identifier via Hoogle. !Search for something via Hoogle. General help via :? or ':help'. Execute a shell command. `:extension Foo` is a shortcut for ` :set -XFoo` Set IHaskell kernel option  `:option`. Load a Haskell module. 3Enable or disable an extensions, packages etc. via `:set`. Emulates GHCi's `:set` "Get info about the identifier via ':info' (or unique prefixes) "Get the type of an expression via ':type' (or unique prefixes) !A block of code to be evaluated. D Each block contains a single element - one declaration, statement, G expression, etc. If parsing of the block failed, the block is instead ? a ParseError, which has the error location and error message. 8An error indicating that parsing the code block failed. 2A full Haskell module, to be compiled and loaded. An IHaskell directive. <A lonely type signature (not above a function declaration). An import statement.  A Haskell statement (as if in a `do` block). %A data type or function declaration. A Haskell expression. !Parse a string into code blocks. FParse a single chunk of code, as indicated by the layout of the code. FFind consecutive declarations of the same function and join them into B a single declaration. These declarations may also include a type C signature, which is also joined with the subsequent declarations. .Parse a directive of the form :directiveName. 3Parse a module and return the name declared in the 'module X where' I line. That line is required, and if it does not exist, this will error. 8 Names with periods in them are returned piece y piece. Directive string. ,Line number at which the directive appears. 'Directive code block or a parse error. " "    Safe-InferredmanyTill p end from hidden manyTill" in that it appends the result of end 2Input must terminate in a space character (like a n)   All message type definitions. NoneOutput of evaluation. &Text to display in the IPython pager. Comms to start. EAn intermediate result which communicates what has been printed thus  far. Display outputs. Display outputs. Current HLint status. +Initialization information for the kernel. Extensions to enable at start. !Code blocks to run before start. :Which directory this kernel should pretend to operate in. What frontend this serves. Kernel options to be set via `:set` and  `:option`. Ways to set this option via  `:option` Ways to set this option via `:set` %Function to update the kernel state. 3All state stored in the kernel between executions. Wrapper for ipython-kernel',s DisplayData which allows sending multiple # results from the same expression. "Display as an interactive widget. $Output target name for this widget. / The actual input parameter should be ignored. FCalled when the comm is opened. Allows additional messages to be sent  after comm open.  Respond to a comm data message. :Close the comm, releasing any resources we might need to. 'A class for displayable Haskell types. IHaskell'0s displaying of results behaves as if these two  overlapping/$undecidable instances also existed: ( instance (Show a) => IHaskellDisplay a $ instance Show a where shows _ = id ?!Widget to open a comm port with. Way to respond to the message. )Widget which is being communicated with.  Sent data. Way to respond to the message.  Widget to close comm port with.  Sent data.   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ -he^ZXUROMJEB><;97510/.iifgi_`abcdi[\]iYiVWiSTiPQiNQi_KLiFGHIiCDiC?@Ai=i=i:i8i6i234i34i34j~}|{zyxwvutsrqponmlk%('&"$# !),+*   None > << \ begin{code} \ end{code} \begin{verbatim} \ end{verbatim}Display help text. #6Present when output should overwrite existing files. $%Which executable to use for IPython. %)A file with commands to load at startup. &!An extension to load at startup. ')Which directory to serve notebooks from. *EGiven a list of command-line arguments, return the IHaskell mode and  arguments to process. +(Get help text for a given IHaskell ode. /     !"#$%&'()*+,#     !"#$%&'()*+,#    '&%$#"! (),*+     '&%$#"! ()*+,interpret flags parsed by IHaskell.Flags None-:ConvertSpec is the accumulator for command line arguments 4@Convert a possibly-incomplete specification for what to convert C into one which can be executed. Calls error when data is missing.  Does this Argument# explicitly request a file format? .Guess the format based on the file extension. -./012345 -./012345 -./012345-./012345NoneconvCell sty cell3 converts a single cell in JSON into text suitable + for the type of lhs file described by the sty 6$the filename of an ipython notebook .the filename of the literate haskell to write  the prefix to add to every line a json array of text lines 5JSON array of output lines containing text or markup 666None,arrayFromTxt makes a JSON array of string s Dihaskell needs this boilerplate at the upper level to interpret the - json describing cells and output correctly. 77774mostly reversible conversion between ipynb and lhs None8used by IHaskell convert .Call fail when the named file already exists. 8888Shell scripting wrapper using Shelly for the notebook, and  console commands. None9Which IPython to use. :(Use the command-line flag provided one. ;,Use the one that IHaskell tries to install. The IPython profile name. %The current IPython profile version. 7 This must be the same as the file in the profile.tar.  The filename used is profileVersionFile. 4Filename in the profile where the version ins kept.  Run IPython with any arguments. "Run while suppressing all output. $Create the directory and return it. (Return the data directory for IHaskell. >>Find a notebook and then convert it into the provided format. I Notebooks are searched in the current directory as well as the IHaskell % notebook directory (in that order). ?Set up IPython properly. @Replace ~! with $HOME if $HOME is defined.  Otherwise, do nothing. +Get the path to an executable. If it doensn't exist, fail with an % error message complaining about it. 9Parse an IPython version string into a list of integers. 5Run an IHaskell application using the given profile. Create the IPython profile. Update the IPython profile. 2Copy the profile files into the IPython profile. 9Insert the IHaskell path into the IPython configuration. 3Get the absolute path to this IHaskell executable. -Check whether IPython is properly installed. Install IPython from source. #9:;<Which IPython to use (user-provided or IHaskell-installed). Whether to suppress output.  IPython command line arguments. IPython output. <=>?@IHaskell profile name. IPython app name. Arguments to IPython. ABCIHaskell profile name. IHaskell profile name. D9:;<=>?@ABCD?ABC=<D>@9;:!9;:<=>?@ABCDNone F&Types of formats to render output to. GRender to HTML. HRender to plain text. #Query Hoogle for the given string. E This searches Hoogle using the internet. It returns either an error ( message or the successful JSON result. ISearch for a query on Hoogle.  Return all search results. J!Look up an identifier on Hoogle. = Return documentation for that identifier. If there are many 5 identifiers, include documentation for all of them. K5Render a Hoogle search result into an output format. &Render a Hoogle result to plain text.  Render a Hoogle result to HTML. E     FGHIJKEFGHIJKIJKFHGEE     FHGIJKNoneM<Encode many displays into a single one. All will be output. NGenerate a plain text display. OGenerate an HTML display. PGenerate an SVG display. QGenerate a LaTeX display. RGenerate a Javascript display. SCGenerate a PNG display of the given width and height. Data must be H provided in a Base64 encoded manner, suitable for embedding into HTML.  The base647 function may be used to encode data into this format. TCGenerate a JPG display of the given width and height. Data must be H provided in a Base64 encoded manner, suitable for embedding into HTML.  The base647 function may be used to encode data into this format. U1Convert from a string into base 64 encoded data. V5Convert from a ByteString into base 64 encoded data. W"For internal use within IHaskell. % Serialize displays to a ByteString. ?Items written to this chan will be included in the output sent B to the frontend (ultimately the browser), the next time IHaskell  has an item to display. X&Take everything that was put into the  at that point  out, and make a  out of it. BThis is unfoldM from monad-loops. It repeatedly runs an IO action < until it return Nothing, and puts all the Justs in a list. J If you find yourself using more functionality from monad-loops, just add > the package dependency instead of copying more code from it. YDWrite to the display channel. The contents will be displayed in the 0 notebook once the current execution call ends. ZAConvenience function for client libraries. Switch to a temporary + directory so that any files we create aren't visible. On Unix, this is  usually /tmp. <these instances cause the image, html etc. which look like:   Display  [Display]  IO [Display]  IO (IO Display) Ibe run the IO and get rendered (if the frontend allows it) in the pretty  form. LMNOPQRSTUVWXYZ !LMNOPQRSTUVWXYZ !YNOSTPQRMLUVZXWLMNOPQRSTUVWXYZNone 7Identifier used when one is needed for proper context. [CGiven parsed code chunks, perform linting and output a displayable ( report on linting warnings and errors. !"#$%&'() [*+,-.[[ !"#$%&'() [*+,-. *Wrapper around GHC API, exposing a single ` interface that runs C a statement, declaration, import, or directive. None / Output of a command evaluation. 0FPublisher for IHaskell outputs. The first argument indicates whether 6 this output is final (true) or intermediate (false). 1Enable debugging output 2Set GHC's verbosity for debugging _<Run an interpreting action. This is effectively runGhc with @ initialization and importing. First argument indicates whether 3 F is handled specially, which cannot be done in a testing environment. 48Initialize our GHC session with imports and a value for it. 5Give a value for the it variable. `"Evaluate some IPython input code. 6@Return the display data for this command, as well as whether it  resulted in an error. &/789:;<0\=>?12@]A^_45`The kernel state. ,Haskell code or other interpreter commands. 'Function used to publish data outputs. BC6DEFGH.Function used to publish intermediate output. Statement to evaluate. Return the output and result. IJKLMNOP\]^_`_`\]^/789:;<0\=?>12@]A^_45`BC6DEFGHIJKLMNOP"Generates tab completion options. NonelCGet which type of completion this is from the surrounding context. m,Get the word under a given cursor location. abcdefghijkQl0The line on which the completion is being done. $Location of the cursor in the line. ;The identifier being completed (pieces separated by dots). mRSTUVW0File filter: test whether to include this file. :Directory filter: test whether to include this directory. )Line contents to the left of the cursor. *Line contents to the right of the cursor. abcdefghijklm kmlajihgfedcb a jihgfedcbkQlmRSTUVW9Inspect type and function information and documentation. NonennnnX !"#$%&'(()*+,-./0123456789:;<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                    !"#$%&'()**+,-./0123456789:;<==>?@AABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o p q r st;uvwxyz{|}~0                          K      !"#$%&'()*+,-./0123'456789:;<=> ? @ A BCDE F G H ? I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` abcdefghiihaskell-0.4.3.0IHaskell.IPython.Message.WriterIHaskell.Eval.ParserPaths_ihaskellIHaskell.IPython.Message.UUIDIHaskell.IPython.TypesIHaskell.IPython.Message.ParserIHaskell.IPython.ZeroMQIHaskell.IPython.StdinIHaskell.BrokenPackagesIHaskell.Eval.EvaluateIHaskell.Eval.UtilIHaskell.Eval.ParseShellIHaskell.TypesIHaskell.FlagsIHaskell.Convert.ArgsIHaskell.Convert.IpynbToLhsIHaskell.Convert.LhsToIpynbIHaskell.ConvertIHaskell.IPythonIHaskell.Eval.HoogleIHaskell.DisplayIHaskell.Eval.LintIHaskell.Eval.CompletionIHaskell.Eval.InfoIHaskell.IPython.Kernel aeson-0.7.0.6Data.Aeson.Types.ClasstoJSONToJSONghc-parser-0.1.3.0Language.Haskell.GHC.Parser layoutChunks LineNumber ColumnNumberErrMsgLoc StringLocunloclineLocatedversion getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameUUIDrandomsrandomMimeTypeMimeJavascript MimeLatexMimeSvgMimeJpgMimePngMimeHtml PlainTextHeightWidth DisplayData StreamTypeStdoutStdinExecutionStateStartingIdleBusyExecuteReplyStatusAbortErrOkMessage SendNothing CommCloseCommDataCommOpencommTargetNamecommUuidcommData InputReply inputValue RequestInput inputPrompt ClearOutputwait ShutdownReplyShutdownRequestrestartPendingObjectInfoReply objectFoundobjectTypeStringobjectDocStringObjectInfoRequest objectName detailLevel CompleteReplycompletionMatchescompletionMatchedTextcompletionTextcompletionStatusCompleteRequest getCodeLine getCursorPos PublishInputinCode PublishOutputreprTextexecutionCountPublishDisplayDatasource displayData PublishStream streamType streamContent PublishStatusexecutionState ExecuteReplystatus pagerOutputexecutionCounterExecuteRequestgetCode getSilentgetStoreHistory getAllowStdingetUserVariablesgetUserExpressionsKernelInfoReply versionListlanguageKernelInfoRequestheader MessageTypeCommCloseMessageCommDataMessageCommOpenMessageInputReplyMessageInputRequestMessageClearOutputMessageShutdownReplyMessageShutdownRequestMessageObjectInfoReplyMessageObjectInfoRequestMessageCompleteReplyMessageCompleteRequestMessage InputMessage OutputMessageDisplayDataMessage StreamMessage StatusMessageExecuteRequestMessageExecuteReplyMessageKernelInfoRequestMessageKernelInfoReplyMessageMetadataUsername MessageHeader identifiers parentHeadermetadata messageId sessionIdusernamemsgTypeProfileip transport stdinPort controlPorthbPort shellPort iopubPortkey TransportTCPIPPort replyType extractPlain parseMessage ZeroMQStdin StdinChannelstdinRequestChannelstdinReplyChannelZeroMQInterfaceChannelsshellRequestChannelshellReplyChannelcontrolRequestChannelcontrolReplyChannel iopubChannel serveProfile serveStdinfixStdinrecordParentHeaderrecordKernelProfilegetBrokenPackages ghc-7.6.3 MonadUtilsliftIOExtFlag UnsetFlagSetFlag extensionFlag setExtensionsetFlagsdocinitGhci evalImportevalDeclarationsgetTypegetDescription DirectiveTypeGetKindGetDoc SearchHoogleGetHelpShellCmd SetExtension SetOptionLoadFile SetDynFlagGetInfoGetType CodeBlock ParseErrorModule Directive TypeSignatureImport Statement Declaration Expression parseStringparseDirective getModuleName parseShellEvaluationResult FinalResultpagerOut startCommsIntermediateResultoutputsCommInfo LintStatusLintOffLintOnInitInfo extensions initCellsinitDirfrontend KernelOpt getOptionName getSetNamegetUpdateKernelState FrontendTypeIPythonNotebookIPythonConsole KernelStategetExecutionCounter getLintStatus getFrontenduseSvg useShowErrors useShowTypesusePager openCommsDisplay ManyDisplayWidgetIHaskellWidget targetNameopencommcloseIHaskellDisplaydisplay ViewFormatLatexMarkdownIpynbHtmlPdfdefaultKernelState kernelOpts IHaskellModeViewKernel ConvertLhsConsoleNotebookShowHelpNotebookFormat IpynbFile LhsMarkdownLhsStyle lhsCodePrefixlhsOutputPrefix lhsBeginCode lhsEndCodelhsBeginOutput lhsEndOutputArgumentHelpConvertLhsStyleConvertToFormatConvertFromFormat ConvertTo ConvertFromOverwriteFiles IPythonFromConfFile Extension ServeFromArgs parseFlagshelp lhsStyleBird ConvertSpecconvertToIpynb convertInput convertOutputconvertLhsStyleconvertOverwriteFilesfromJustConvertSpec toConvertSpec ipynbToLhs lhsToIpynbconvert WhichIPythonExplicitIPythonDefaultIPythongetIHaskellDirdefaultConfFile nbconvert setupIPythonsubHome runConsole runNotebook readInitInfogetSandboxPackageConf HoogleResult OutputFormatHTMLPlainsearchdocumentrenderBase64manyplainhtmlsvglatex javascriptpngjpgencode64base64serializeDisplaydisplayFromChan printDisplayswitchToTmpDirlint Interpreter typeCleaner globalImports interpretevaluateCompletionType KernelOptionFilePath HsFilePath ModuleName QualifiedDynFlag IdentifierEmptycompletecompletionTypecompletionTargetinfocatchIObindirlibdirdatadir libexecdir sysconfdir $fToJSONUUID$fFromJSONUUIDshowMessageType$fShowMimeType$fSerializeMimeType$fSerializeDisplayData$fSerializeText$fShowDisplayData$fShowExecuteReplyStatus$fFromJSONMessageType$fToJSONMessageHeader$fToJSONTransport$fFromJSONTransport$fToJSONProfile$fFromJSONProfiledisplayDataToJson$fToJSONStreamType$fToJSONExecutionStateemptyMap emptyListintsstring$fToJSONMessage parseHeaderkernelInfoRequestParserexecuteRequestParser LByteStringnoHeaderparsercompleteRequestParserobjectInfoRequestParsershutdownRequestParserinputReplyParsercommOpenParsercommDataParsercommCloseParser serveSocket heartbeatshellcontroliopubreceiveMessage sendMessage getInputLinestdinInterface stdinOnce BrokenPackage packageID brokenDepscheckident dependency$fShowBrokenPackage OutputableSDocshowSDocDynFlagspprColsGhcMonadgetSessionDynFlagsGHCrunGhcparseCodeChunk joinFunctionsactivateParsingExtensions joinLinesmanyTillwordseolquote manyTill1 unescapedChar quotedStringunquotedStringword separator$fSemigroupDisplay$fMonoidDisplay$fSerializeDisplay $fShowWidget$fIHaskellWidgetWidget$fIHaskellDisplayWidget$fReadViewFormat$fShowViewFormatallModes ipythonFlaguniversalFlagsstorenotebookconsolekernel lhsStyleTexview ihaskellArgsnoArgs isFormatSpecfromExt mergeArgsmergeArgconvCellconcatWithPrefixtoStr convOutputsgetTexts arrayFromTxt boilerplateCellCodeCellLine MarkdownLine OutputLineCodeLineisCodeisOutputisMD isEmptyMDuntag encodeCells cellToValgroupClassified classifyLines failIfExistsipythonProfileprofileVersionprofileVersionFileipythonquietRunensure ihaskellDirpath parseVersion runIHaskellsetupIPythonProfileupdateIPythonProfile copyProfileinsertIHaskellPathgetIHaskellPathipythonInstalledinstallIPython ipythonDiripythonExePath notebookDiripythonSourceDir writeInitInforunTmpquery renderPlain renderHtmlNoResult DocResult SearchResultHoogleResponselocationselfdocs renderSelf renderDocsextractPackageNameextractModuleNamedivspanlink$fFromJSONHoogleResponse $fFromJSON[] displayChanunfoldM$fIHaskellDisplayIO$fIHaskellDisplay[]$fIHaskellDisplayDisplayData$fIHaskellDisplayDisplay lintIdentLintSuggestionSuggestfoundwhyNotseverity suggestion ExtsModule hlintSettingsshowIdea createModuleplainSuggestionhtmlSuggestionsshowSuggestionEvalOut Publisherdebug ghcVerbositybaseGHC.IO.Handle.FDstdininitializeImportsinitializeItVariable evalCommand evalStatus evalResult evalState evalPager evalComms ErrorOccurredFailureSuccessignoreTypePrefixeswritesafely wrapExecution hoogleResults readChars doLoadModulekeepingItVariablecapturedStatement formatErrorformatErrorWithClassformatParseError formatGetType formatType displayErrormono $fMonadIOGhcgetTrueModuleNamegetHome dirExpand unDirExpand completePathcompletePathWithExtensionscompletePathFilter