<div dir="ltr"><div>I think there is currently a more general interest in this, and the ghc-mod guys are thinking on similar lines, see <a href="https://github.com/kazu-yamamoto/ghc-mod/issues/349">https://github.com/kazu-yamamoto/ghc-mod/issues/349</a><br><br></div>Alan<br></div><div class="gmail_extra"><br><div class="gmail_quote">On Sat, Oct 18, 2014 at 5:48 PM, Christopher Done <span dir="ltr"><<a href="mailto:chrisdone@gmail.com" target="_blank">chrisdone@gmail.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr"><div><p style="margin:1.2em 0px!important">Good evening,</p>
<p style="margin:1.2em 0px!important">So I’ve been working on Haskell user-facing tooling in general for<br>some years. By that I mean the level of Emacs talking with Haskell<br>tools.</p>
<p style="margin:1.2em 0px!important">I wrote the interactive-haskell-mode (most functionality exists<br><a href="https://github.com/haskell/haskell-mode/blob/master/haskell-process.el#L1" target="_blank">in this file</a>).<br>which launches a GHCi process in a pipe and tries very earnestly to<br>handle input/output with the process reasonably.</p>
<p style="margin:1.2em 0px!important">For Emacs fanciers: Written in Elisp, there’s a nice command queue<br>that you put commands onto, they will all be run on a FIFO one-by-one<br>order, and eventually you’ll get a result back. Initially it was just<br>me using it, but with the help of Herbert Riedel it’s now a mode on<br>equal footing with the venerable inferior-haskell-mode all ye Emacs<br>users know and love. It’s part of haskell-mode and can be enabled by<br>enabling the interactive-haskell-mode minor mode.</p>
<p style="margin:1.2em 0px!important">For years I’ve been using GHCi as a base and it’s been very reliable<br>for almost every project I’ve done (the only exceptions are things<br>like SDL and OpenGL, which are well known to be difficult to load in<br>GHCi, at least on Linux). I think we’ve built up<br><a href="https://github.com/haskell/haskell-mode/wiki/Haskell-Interactive-Mode" target="_blank">a good set of functionality</a><br>purely based on asking GHCi things and getting it to do things.</p>
<p style="margin:1.2em 0px!important">I literally use GHCi for everything. For type-checking, type info, I<br>even send “:!cabal build” to it. Everything goes through it. I love my<br>GHCi.</p>
<p style="margin:1.2em 0px!important">Now, I’m sort of at the end of the line of where I can take GHCi. Here<br>are the problems as I see them today:</p>
<ol style="margin:1.2em 0px;padding-left:2em">
<li style="margin:0.5em 0px">There is no programmatic means of communicating with the<br>process. I can’t send a command and get a result cleanly, I have to<br>regex match on the prompt, and that is only so reliable. At the<br>moment we solve this by using \4 (aka ‘END OF TRANSMISSION’). Also<br>messages (warnings, errors, etc.) need to be parsed which is also<br>icky, especially in the REPL when e.g. a defaulted Integer warning<br>will mix with the output. Don’t get me started on handling<br>multi-line prompts! Hehe.</li>
<li style="margin:0.5em 0px">GHCi, as a REPL, does not distinguish between stdout, stderr and<br>the result of your evaluation. This can be problematic for making a<br>smooth REPL UI, your results can often (with threading) be<br>interspersed in unkind ways. I cannot mitigate this with any kind<br>of GHCi trickery.</li>
<li style="margin:0.5em 0px">It forgets information when you reload. (I know this is intentional.)</li>
<li style="margin:0.5em 0px">Not enough information is exposed to the user. (Is there ever? ;)</li>
<li style="margin:0.5em 0px">There is a time-to-market overhead of contributing to GHCi — if I<br>want a cool feature, I can write it on a locally compiled version<br>of GHC. But for the work projects I have, I’m restricted to given<br>GHC versions, as are other people. They have to wait to get the<br>good features.</li>
<li style="margin:0.5em 0px">This is just a personal point — I’ve like to talk to GHCi over a<br>socket, so that I can run it on a remote machine. Those familiar<br>with Common Lisp will be reminded of SLIME and Swank.</li>
</ol>
<p style="margin:1.2em 0px!important">Examples for point 4 are:</p>
<ul style="margin:1.2em 0px;padding-left:2em">
<li style="margin:0.5em 0px">Type of sub-expressions.</li>
<li style="margin:0.5em 0px">Go to definition of thing at point (includes local scope).</li>
<li style="margin:0.5em 0px">Local-scope completion.</li>
<li style="margin:0.5em 0px">A hoogle-like query (as seen in Idris recently).</li>
<li style="margin:0.5em 0px">Documentation lookup.</li>
<li style="margin:0.5em 0px">Suggest imports for symbols.</li>
<li style="margin:0.5em 0px">Show core for the current module.</li>
<li style="margin:0.5em 0px">Show CMM for the current module, ASM, etc. SLIME can do this.</li>
<li style="margin:0.5em 0px">Expand the template-haskell at point.</li>
<li style="margin:0.5em 0px">The :i command is amazingly useful, but programmatic access would be<br>even better.¹</li>
<li style="margin:0.5em 0px">Case split anyone?</li>
<li style="margin:0.5em 0px">Etc.</li>
</ul>
<p style="margin:1.2em 0px!important">¹I’ve integrated with it in Emacs so that I can C-c C-i any identifier<br>  and it’ll popup a buffer with the :i result and then within that<br>  buffer I can drill down further with C-c C-i again. It makes for<br>  very natural exploration of a type.</p>
<p style="margin:1.2em 0px!important">You’ve seen some of these features in GHC Mod, in hdevtools, in the FP Haskell<br>Center, maybe some are in Yi, possibly also in Leksah (?).</p>
<p style="margin:1.2em 0px!important">So in light of point (5), I thought: I’ve used the GHC API before, it<br>can do interactive evaluation, why not write a project like<br>“ghc-server” which encodes all these above ideas as a “drop-in”<br>replacement for GHCi? After all I could work on my own without anybody<br>getting my way over architecture decisions, etc.</p>
<p style="margin:1.2em 0px!important">And that’s what I did. It’s<br><a href="https://github.com/chrisdone/ghc-server" target="_blank">here</a>. Surprisingly, it kind of works. You run it in your directoy like you would do “cabal repl”<br>and it sets up all the extensions and package dependencies and starts<br>accepting connections. It will compile across three major GHC<br>versions. Hurray! Rub our hands together and call it done, right?<br>Sadly not, the trouble is twofold:</p>
<ol style="margin:1.2em 0px;padding-left:2em">
<li style="margin:0.5em 0px">The first problem with this is that every three projects will<br>segfault or panic when trying to load in a project that GHCi will<br>load in happily. The reasons are mysterious to me and I’ve already<br>lugged over the GHC API to get to this point, so that kind of thing<br>happening means that I have to fall back to my old GHCi-based<br>setup, and is disappointing. People have similar complaints of GHC<br>Mod & co. “Getting it to work” is a deterrant.</li>
<li style="margin:0.5em 0px">While this would be super beneficial for me, and has been a good<br>learning experience for “what works and what doesn’t”, we end up<br>with yet another alternative tool, that only a few people are<br>using.</li>
<li style="margin:0.5em 0px">There are just certain behaviours and fixes here and there that<br>GHCi does that take time to reproduce.</li>
</ol>
<p style="margin:1.2em 0px!important">So let’s go back to the GHCi question: is there still a development<br>overhead for adding features to GHCi? Yes, new ideas need acceptance<br>and people have to wait (potentially a year) for a new feature that<br>they could be using right now.</p>
<p style="margin:1.2em 0px!important">An alternative method is to do what Herbert did which is to release a<br><a href="http://hackage.haskell.org/package/ghci-ng" target="_blank">“ghci-ng”</a> which sports<br>new shiny features that people (with the right GHC version) will be<br>able to compile and use as a drop-in for GHCi. It’s the same codebase,<br>but with more stuff! An example is the “:complete” command, this lets<br>IDE implementers do completion at least at the REPL level. Remember<br>the list of features earlier? Why are they not in GHCi?</p>
<p style="margin:1.2em 0px!important">So, of course, this got me thinking that I could instead make<br>ghc-server be based off of GHCi’s actual codebase. I could rebase upon<br>the latest GHC release and maintain 2-3 GHC versions backwards. That’s<br>certainly doable, it would essentially give me “GHCi++”. Good for me,<br>I just piggy back on the GHCi goodness and then use the GHC API for<br>additional things as I’m doing now.</p>
<p style="margin:1.2em 0px!important">But is there a way I can get any of this into the official repo? For<br>example, could I hack on this (perhaps with Herbert) as “ghci-ng”,<br>provide an alternative JSON communication layer (e.g. via some<br>—use-json flag) and and socket listener (—listen-on ), a way<br>to distinguish stdout/stderr (possibly by forking a process, unsure at<br>this stage), and then any of the above features (point 4) listed. I<br>make sure that I’m rebasing upon HEAD, as if to say ghci-ng is a kind<br>of submodule, and then when release time comes we merge back in any<br>new stuff since the last release. Early adopters can use<br>ghci-ng, and everyone benefits from official GHC releases.</p>
<p style="margin:1.2em 0px!important">The only snag there is that, personally speaking, it would be better<br>if ghci-ng would compile on older GHC versions. So if GHC 7.10 is the<br>latest release, it would still be nice (and it <em>seems</em> pretty<br>feasible) that GHC 7.8 users could still cabal install it without<br>issue. People shouldn’t have to wait if they don’t have to.</p>
<p style="margin:1.2em 0px!important">Well, that’s everything. Thoughts? </p><p style="margin:1.2em 0px!important">Ciao!<br></p>
<div title="MDH:SGksPGJyPjxicj5TbyBJJ3ZlIGJlZW4gd29ya2luZyBvbiBIYXNrZWxsIHVzZXItZmFjaW5nIHRv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" style="min-height:0;font-size:0em;padding:0;margin:0">​</div></div></div>
<br>_______________________________________________<br>
ghc-devs mailing list<br>
<a href="mailto:ghc-devs@haskell.org">ghc-devs@haskell.org</a><br>
<a href="http://www.haskell.org/mailman/listinfo/ghc-devs" target="_blank">http://www.haskell.org/mailman/listinfo/ghc-devs</a><br>
<br></blockquote></div><br></div>