structured-haskell-mode

> Structure editors haven't really taken off yet despite several historical and contemporary attempts. This is a nice contemporary one: https://github.com/projectional-haskell/structured-haskell-m... Lisps also have all kinds of options available in Emacs, but it is more special to see this outside of the land of s-expressions.

I agree in general that sexps provide the best editing experience currently, but that's just a matter of tooling, it's not an inherent property of sexps vs infix or whitespace-dependent syntax. Check out [0], a structured editing mode for Haskell, a whitespace-sensitive language. Incidentally, while I have no problem with Lisps (I've used Clojure for about a year), I do prefer infix notation, precisely because it's not homogeneous. [0] https://github.com/chrisdone/structured-haskell-mode

Lisp is certainly amenable to this, and structured editors for lisp have been around for a long time, but the concept is not specific to lisp except inasmuch as it's much easier to implement since the syntax is so similar to the AST. For instance, I like to use Paredit [1] for elisp and Racket hacking, and there's a similar mode for Haskell in emacs [2]. [1] https://www.emacswiki.org/emacs/ParEdit [2] https://github.com/chrisdone/structured-haskell-mode

Reminds me of http://www.lamdu.org/ while trying to remember the name I discovered: https://www.facebook.com/notes/kent-beck/prune-a-code-editor... http://jetbrains.com/mps https://github.com/cxxtree/cxxtree http://www.greenfoot.org/frames/ http://unisonweb.org/ https://github.com/chrisdone/structured-haskell-mode https://www.emacswiki.org/emacs/ParEdit https://github.com/projectured/projectured

Yeah, I am pretty excited about the idea of IDEs just presenting ASTs instead of text (of course can always save as text). There's a haskell structured mode that tries to do a similar thing. It might seem silly, but the biggest impediment I can think of is copy-pasting code from elsewhere. If your variable names are different, the IDE should reject the code (since you shouldn't be able to commit variables that don't exist), but then what do you do? Open it in Notepad and "fix" it? EDIT: structured haskell mode, complete with GIFs showing how it works https://github.com/chrisdone/structured-haskell-mode#feature...

That Structured Haskell Mode (https://github.com/chrisdone/structured-haskell-mode) readme has some very interesting gifs to show how things work. It's pretty powerful, and I use SHM in my Haskell stuff to mostly good effect. I just have some issues involving the default indentation that I need to get round to fixing, and I haven't figured out how to surround a block with square brackets yet. But otherwise, very good stuff.

An interesting idea that's definitely worth exploring. However, I think the conflict between tree-based editing and normal editors is completely unnecessary. In fact, you can actually get basic tree-based editing today in Emacs! The easiest language to support like this is Lisp because its syntax is about as close to pure tree as possible. And, indeed, Emacs has had structural editing for lisp for a while in the form of Paredit[1]. More recently, somebody extended this idea to Haskell[2] which is interesting because Haskell has one of the more complex, persnickety syntaxes around. I'm not saying either of these are as good as dedicated editors—I'm not even convinced they could be as good—but they are low-cost ways to try these ideas out right now without abandoning general-purpose text editing or creating a brand new tool. [1]: http://dan

Their IDE is web only, though they just open sourced a good portion of it. I have found that most people use vim or emacs. If you are trying to decide, I'd pick emacs, as Chris Done has written some nice scripts (https://github.com/chrisdone/structured-haskell-mode). Personally I use vim. Also check out ghc-mod and hdevtools.

There are all sorts of tools, even for refactoring. Maybe not to the degree of Java, no. Although, haskell code tends to have less boilerplate, so there is less toolig for manipulating boilerplate. (Not to say there are other tools that could be improved). But the situation is far from dire. -- Vim: haskellmode-vim for show type and insert type, among other things. ghcmod-vim for HLint and HCheck, also used by Syntastic and NeoComplCache. neco-ghc uses ghcmod-vim for nifty Haskell completion, powered by neocomplcache. Syntastic automatic syntax checking for vim. --Emacs: structured-haskell-mode: https://github.com/chrisdone/structured-haskell-mode haskell-emacs: http://chrisdone.com/posts/haskell-emacs

There is a really great mode [0] for haskell that does the same thing as hl-sexp-mode. Oh and did I mention it fully supports structured editing? These kind of modes really make me question why programs are still written in text instead of ADTs... We don't need to run lexers and parsers to do our syntax highlighting and other fancy stuff... it would be awesome. [0] https://github.com/chrisdone/structured-haskell-mode

Emacs's structured editing, in the style of paredit[1], sounds very similar to a text-based version of syntax-directed editing (SDE). Designed for Lisp and S-expressions, it's a system that lets you edit and navigate around nested expressions at a syntactic rather than textual language. As you type, the correct level of nesting is maintained and there are commands for moving and editing code in terms of s-expressions rather than characters. In practice, it's very easy to start using and very powerful... but requires using Lisp. It'll seem odd if you're not regularly a Lisp user. Happily, this idea can generalize well enough to distinctly non-Lisp languages. Structured Haskell mode[2] does this for Haskell, which has a less regular and sparser syntax than s-expressions. The documentation has a bunch of handy animations showing the various

Actually, you can have paredit-style structured editing for whatever languages you want to support. For example, there is a pretty capable structured editing mode for Haskell[1], which has a syntax significantly less regular than s-expressions. (On the other hand, it's still more regular than most languages...) [1]: https://github.com/chrisdone/structured-haskell-mode

Have you tried structured-haskell-mode[1]? There are video demonstrations here[2]. [1]: https://github.com/chrisdone/structured-haskell-mode [2]: https://www.youtube.com/playlist?list=PLlzKKtH5TyE-R-k86na3b...