haskell-interactive-bring': Use pop-to-buffer'.

[the-kenny]

This commit removes counter-intuitive logic when bringing a project buffer to the front.

One could argue that we want to make the old behavior configurable. If so, please comment here and I'll add a config option.

Fixes #710.

[geraldus]

This behaviour is exact what I expect from haskell-interactive-bring. Let's see what other people say.

[ivan-m]

Can you please describe the behaviour that this implements and how it differs from the current behaviour? I did look at #710 but don't really understand the problem (maybe I'm just used to dealing with the current behaviour).

[geraldus]

@ivan-m I always have several windows layout (most of the time there are only two of them, but rarely I use three or four also). If I start new session using haskell-interactive-bring it replaces all my windows with single one visiting session's (REPL's) buffer. This is annoying to me, because in this case I have to split windows again, and revisit all needed buffers. Though I use REPL occasionally, but usually I need it for type info and compilation only. New behaviour does not breaks layout, just pops session buffer.

Here is a quick demo of current behaviour.

[the-kenny]

The old behavior removed all window-splits in the current frame when
bringing the interaction buffer to the front except when there were
exactly two windows (e.g. one split) and one of them was the interaction
buffer.

The new behavior relies on the standard Emacs function to bring some
background buffer to the front. It will show the buffer in some
window, preferably not the current one (so current buffer showing code
will still be visible) and splits if necessary.

If the interaction buffer is currently visible on another frame, that
frame will be made visible.

The reason I implemented this was that I mostly work on high-resolution
displays with a fullscreen emacs frame. That frame is split multiple
times, showing multiple code buffers.

The old behavior of `haskell-interactive-bring' threw away all these
splits and left me with just one gigantic haskell interaction buffer.

Using `pop-to-buffer' instead of self-written logic is more robust and
future-proof. It's also the "standard" way of bringing some buffer to
the front (See cider
https://github.com/clojure-emacs/cider/blob/master/cider-interaction.el#L411
or even inf-haskell: https://github.com/the-kenny/haskell-mode/blob/master/inf-haskell.el#L205)

[gracjan]

@the-kenny: Thanks for great explanation. Merged.