search

haskell / haskell-mode

Emacs mode for Haskell
http://haskell.github.io/haskell-mode/
GNU General Public License v3.0
1.32k stars 340 forks source link

Repl hanging #447

Closed MichaelXavier closed 8 years ago

MichaelXavier commented 9 years ago

Fair warning: this isn't going to have great details on how to reproduce this issue. I'm mostly looking for some guidance on how to tease out what's going on here.

I use the interactive haskell process in a large project. Pretty consistently now if I haskell-process-load-or-reload it will load the file fine, but then the repl will essentially get stuck. Subsequent calls to haskell-process-load-or-reload will just put in the minibuffer "No changes need to be saved" and not do anything. I also can't enter any commands on the repl. When I strace the repl process I see it hanging on a wait4.

This doesn't seem to really happen on smaller project, which makes this hard to reproduce.

Some system info:

The Glorious Glasgow Haskell Compilation System, version 7.6.3
cabal-install version 1.20.0.3
using version 1.20.0.0 of the Cabal library
haskell-mode version 20141130.1012

Any ideas on how I can troubleshoot this/get you more info?

Thanks!

karljs commented 9 years ago

I would start by setting haskell-process-log to t via customize or in your init file and then seeing what the log output looks like.

MichaelXavier commented 9 years ago

I'm not sure if this is it but I just had a session fail and the last thing in the log is the usage for hasktags:

:!cd /home/michael/src/whatever && find . -name '*.hs' -or -name '*.lhs' -or -name '*.hsc' -print0 | xargs -0 hasktags -e -x
<- Usage: hasktags [OPTION...] [files or directories...]
   directories will be replaced by DIR/**/*.hs DIR/**/*.lhs
   Thus hasktags . tags all important files in the current
   directory.

   If directories are symlinks they will not be followed
   unless you pass -L.

<- 
   A special file "STDIN" will make hasktags read the line separated file
   list to be tagged from STDIN.

     -c            --ctags                        generate CTAGS file (ctags)
     -e            --etags                        generate ETAGS file (etags)
     -b            --both                         generate both CTAGS and ETAGS
     -a            --append                       append to existing CTAGS and/or ETAGS file(s). After this file will no longer be sorted!
                   --ignore-close-implementation  ignores found implementation if its closer than 7 lines  - so you can jump to definition in one shot
     -o            --output=                      output to given file, instead of 'tags', '-' file is stdout
     -f            --file=                        same as -o, but used as compatibility with ctags
     -x            --extendedctag                 Generate additional information in ctag file.
                   --cache                        Cache file data.
     -L            --follow-symlinks              follow symlinks when recursing directories
     -S[.hs,.lhs]  --suffixes[=.hs,.lhs]          list of hs suffixes including "."
     -R            --tags-absolute                make tags paths absolute. Useful when setting tags files in other directories
     -h            --help                         This help

I find that if I just execute that find command, find . -name '*.hs' -or -name '*.lhs' -or -name '*.hsc' -print0 with -print0 at the end, it produces nothing. Omitting it, it produces many lines of results. I've tried moving that -print0 around to no effect. I don't understand find's strange expression language. However, it looks like with hasktags we could eliminate print0 and xargs: find . -name '*.hs' -or -name '*.lhs' -or -name '*.hsc' | hasktags -e -x STDIN since according to the docs, the special filename STDIN will use stdin and expect line-delimited filenames, which is what find produces!

I'm going to modify my local copy of haskell-mode and see if this helps. Either way though, I think this would be a good change. I'd be happy to submit a PR for it if people agreed that it was appropriate.

MichaelXavier commented 9 years ago

Unfortunately this didn't resolve the issue. The hanging seems to be at random. It happens to me often enough that if you need any diagnostics on the running process I should be able to get them. Right now its locked up in my session and the last entries in the log seem pretty uninteresting:

-> :info Milliseconds
<- newtype TrackerPacker.Types.Duration = Milliseconds Int
        -- Defined in `TrackerPacker.Types'
   
-> :info n
<- 
   Top level: Not in scope: `n'
chrisdone commented 9 years ago

It would be good if you clear your process log buffer and do a session from scratch and reproduce the problem. Everything you've pasted so far seems fine.

MichaelXavier commented 9 years ago

The only problem there is that this doesn't seem to happen deterministically. Sometimes I can get through 20+ minutes of normal work before it crops up. Right now I'm actually (attempting to) debugger step through haskell-process-load-file. I wonder if there's any reflection I can do on the session or haskell process state that may illuminate things.

chrisdone commented 9 years ago

It'll usually happen if some commmand (like tags) or whatever locks up the queue. Any subsequent commands in the queue won't be run, including any REPL commands. You can see what it was trying to do when it looks up by looking at the contents of (haskell-process)

MichaelXavier commented 9 years ago

Ah now this is getting interesting. That produced about 3400 lines of output but I see several times this snippet:

   (inferior-process . #<process dynaweb>)
   (is-restarting)
   (current-command .
                    [cl-struct-haskell-command
                     (#0)
                     (lambda
                       (state)
                       (haskell-process-send-string
                        (car state)
                        (if
                            (string-match "^[A-Za-z_]"
                                          (cdr state))
                            (format ":info %s"
                                    (cdr state))
                          (format ":info (%s)"
                                  (cdr state)))))
                     nil
                     (lambda
                       (state response)
                       (if
                           (or
                            (string-match "^Top level" response)
                            (string-match "^<interactive>" response))
                           nil
                         (haskell-mode-message-line response)))])
   (suggested-imported)
   (sent-stdin)
   (evaluating)
MichaelXavier commented 9 years ago

Is there some way a command can either be timed out or aborted by the repl? I'm kind of at a loss here. When this feature is working well it saves me tons of time.

chrisdone commented 9 years ago

C-c C-c?

MichaelXavier commented 9 years ago

On a whim when watching the log I saw that i was using flymake-haskell-multi, which in turn was using flymake alongside flycheck on my haskell code. I saw interleaved calls from haskell-mode and flymake and figured this could be the source of a race condition. I've uninstalled that package and so far so good. I figure by the end of the day if I don't get any lockups, that must have been the issue.

MichaelXavier commented 9 years ago

Damn. Unfortunately the problem still persists. Is there anything I can do to provide more info? I'm happy to do as much work as necessary to get this figured out, its just that my elisp debugging skills aren't where they need to be at yet to debug it myself.

zovt commented 9 years ago

I'm having the same problem myself. For me at least, it would seem that I can

  1. Load a haskell file into a new GHCi session using C-c C-l
  2. Use the REPL at this point to evaluate functions, etc.
  3. Switch back to the source code using either C-c C-z or C-x o
  4. Make some changes, save source. Use C-c C-b to switch to the REPl

It's after 4 when it locks up with no indication

sritchie commented 9 years ago

I'm seeing this issue as well. It looks like https://github.com/haskell/haskell-mode/issues/536 might be a duplicate. (haskell-process-clear)unhangs my repl; I've bound that command tof7` for now so I can at least keep moving. This happens a lot, and seems to be triggered by hasktags in my case.

lukehoersten commented 9 years ago

This happens a lot for me. It does seem to happen related to saving though I don't use hasktags so I think it's unrelated to that. @chrisdone helped me confirm that stuff is getting stuck in my haskell-process queue so (haskell-process-clear) clears things out for me as well though the real question is: why is the queue getting jammed up? Weirdly I can continue to use the haskell-process repl when this occurs.

gracjan commented 9 years ago

@LukeHoersten: next time it hangs can you check what is the output of (haskell-commands-process)?

sritchie commented 9 years ago

Here's the output for me. I cleared the process, moved some text around, saved the file and noticed a freeze.

((name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (#0 . "P.String") #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[... "Â=ƒà   @ÄÅÆÇ   @!!\"\"‡Ã @ÄÈÆÇ   @!!ÉÊ$\"‡" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[... "AƒÂÃ@!!ÄA!ˆ)ÅÆ!‡" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command (... #0 "1:type IsString" 0) #[... "dbˆÂcˆdà ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]] [cl-struct-haskell-command (... #0 "1" 0) #[... "dbˆÂcˆdà    ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 1460 in *course*> . #<marker (moves after insertion) at 1460 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command ... #[... "Â=ƒà    @ÄÅÆÇ   @!!\"\"‡Ã @ÄÈÆÇ   @!!ÉÊ$\"‡" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[... "AƒÂÃ@!!ÄA!ˆ)ÅÆ!‡" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command ... #[... "dbˆÂcˆdà  ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]] [cl-struct-haskell-command ... #[... "dbˆÂcˆdà   ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #1)))
lukehoersten commented 9 years ago

Mine looked very similar to that last time I captured it during a freeze. I had a whole bunch of binary output in mine as well. I'll capture it next time it happens.

lukehoersten commented 9 years ago

Here's one I got to happen in my test code.

((name . "test") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (:process #0 :session ... :filename "/Users/lhoersten/Code/haskell/test/Test.hs" :callback #[128 "ÁÂÀ#‡" [[cl-struct-flycheck-syntax-check #<buffer Test.hs> haskell-process nil] apply flycheck-report-buffer-checker-status] 5 "

(fn &rest ARGS)"] :buffer #<buffer Test.hs> :original #("{-# LANGUAGE OverloadedStrings #-}

module Test where

import           Control.Applicative
import           Data.Attoparsec.ByteString.Char8
import           Data.ByteString                  (ByteString)
import           Data.Word
import           Prelude                          hiding (takeWhile)

import           Control.Monad.Trans.Reader       (ReaderT (..), )
import           Control.Monad.Trans.State        (StateT (..))

test :: IO ()
test = print (feed (parse tagParser \"#hey #there\") \"\")

tagParser :: Parser [ByteString]
tagParser = word `sepBy1` space
  where word = char '#' *> takeWhile (not . isSpace)

stateToReaderT :: (Monad m) => ReaderT s (StateT s m) a -> StateT s m a
stateToReaderT m = get >>= runReaderT m

runMyReaderTStack :: (Monad m) => ReaderT s1 (ReaderT s2 m) a -> StateT s1 (StateT s2 m) a
runMyReaderTStack = undefined" 0 2 ... 2 34 ... 34 36 ... 36 42 ... 42 43 ... 43 47 ... 47 48 ... 48 53 ... 53 55 ... 55 61 ... 61 72 ... 72 91 ... 91 92 ... 92 98 ... 98 109 ... 109 141 ... 141 142 ... 142 148 ... 148 159 ... 159 174 ... 174 192 ... 192 193 ... 193 203 ... 203 204 ... 204 205 ... 205 211 ... 211 222 ... 222 231 ... 231 232 ... 232 238 ... 238 249 ... 249 256 ... 256 282 ... 282 288 ... 288 289 ... 289 290 ... 290 299 ... 299 300 ... 300 301 ... 301 302 ... 302 308 ... 308 319 ... 319 326 ... 326 332 ... 332 338 ... 338 345 ... 345 346 ... 346 352 ... 352 353 ... 353 360 ... 360 361 ... 361 362 ... 362 364 ... 364 365 ... 365 366 ... 366 367 ... 367 368 ... 368 369 ... 369 375 ... 375 386 ... 386 411 ... 411 418 ... 418 419 ... 419 420 ... 420 426 ... 426 427 ... 427 428 ... 428 430 ... 430 431 ... 431 432 ... 432 433 ... 433 434 ... 434 435 ... 435 439 ... 439 440 ... 440 442 ... 442 443 ... 443 445 ... 445 446 ... 446 447 ... 447 448 ... 448 449 ... 449 453 ... 453 454 ... 454 455 ... 455 462 ... 462 463 ... 463 468 ... 468 469 ... 469 485 ... 485 498 ... 498 499 ... 499 500 ... 500 502 ... 502 503 ... 503 505 ... 505 514 ... 514 515 ... 515 517 ... 517 518 ... 518 524 ... 524 525 ... 525 526 ... 526 536 ... 536 537 ... 537 538 ... 538 547 ... 547 548 ... 548 549 ... 549 555 ... 555 563 ... 563 572 ... 572 577 ... 577 583 ... 583 584 ... 584 590 ... 590 591 ... 591 592 ... 592 593 ... 593 594 ... 594 596 ... 596 607 ... 607 608 ... 608 612 ... 612 613 ... 613 621 ... 621 622 ... 622 623 ... 623 624 ... 624 625 ... 625 639 ... 639 640 ... 640 642 ... 642 643 ... 643 644 ... 644 649 ... 649 651 ... 651 652 ... 652 653 ... 653 655 ... 655 656 ... 656 663 ... 663 666 ... 666 667 ... 667 673 ... 673 677 ... 677 678 ... 678 681 ... 681 683 ... 683 684 ... 684 690 ... 690 697 ... 697 711 ... 711 714 ... 714 715 ... 715 720 ... 720 723 ... 723 739 ... 739 756 ... 756 757 ... 757 759 ... 759 760 ... 760 761 ... 761 766 ... 766 768 ... 768 769 ... 769 770 ... 770 772 ... 772 773 ... 773 780 ... 780 784 ... 784 785 ... 785 792 ... 792 797 ... 797 798 ... 798 801 ... 801 803 ... 803 804 ... 804 810 ... 810 814 ... 814 815 ... 815 821 ... 821 826 ... 826 827 ... 827 830 ... 830 847 ... 847 848 ... 848 849 ... 849 860 ... 860 863 ... 863 884 ... 884 885 ...)) (lambda ... ...) (lambda ... ...) (lambda ... ...)] [cl-struct-haskell-command (#0) #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (... #0 "load \"/Users/lhoersten/Code/haskell/test/Test.hs\"" nil #<buffer Test.hs>) #[... "Á‰A@²ÂÃAA@\"\"‡" [state haskell-process-send-string format ":%s"] 5] #[... "‰A@²  Ã#‡" [state buffer haskell-process-live-build nil] 4] #[... "Â@‰A@² AAA@AAAA@%‡" [state response haskell-process-load-complete] 6]] [cl-struct-haskell-command (... #0 "load \"/Users/lhoersten/Code/haskell/test/Test.hs\"" nil #<buffer Test.hs>) #[... "Á‰A@²ÂÃAA@\"\"‡" [state haskell-process-send-string format ":%s"] 5] #[... "‰A@²   Ã#‡" [state buffer haskell-process-live-build nil] 4] #[... "Â@‰A@² AAA@AAAA@%‡" [state response haskell-process-load-complete] 6]]) (inferior-process . #<process test>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "test") (next-error-region #<marker at 124 in *test*> . #<marker (moves after insertion) at 124 in *test*>) (next-error-locus) (interactive-buffer . #<buffer *test*>) (target . "") (current-dir . "/Users/lhoersten/Code/haskell/test/") (cabal-checksum . "f4182843bba98f8a3c88c77eb09ce4a0") (cabal-dir . "/Users/lhoersten/Code/haskell/test/") (process (name . "test") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command ... ... ... ...] [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command ... #[... "Á‰A@²ÂÃAA@\"\"‡" [state haskell-process-send-string format ":%s"] 5] #[... "‰A@²  Ã#‡" [state buffer haskell-process-live-build nil] 4] #[... "Â@‰A@² AAA@AAAA@%‡" [state response haskell-process-load-complete] 6]] [cl-struct-haskell-command ... #[... "Á‰A@²ÂÃAA@\"\"‡" [state haskell-process-send-string format ":%s"] 5] #[... "‰A@²    Ã#‡" [state buffer haskell-process-live-build nil] 4] #[... "Â@‰A@² AAA@AAAA@%‡" [state response haskell-process-load-complete] 6]]) (inferior-process . #<process test>) (is-restarting) (current-command . [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #1)))
gracjan commented 9 years ago

The command that is stuck is this one:

(current-command .
  [cl-struct-haskell-command
     ...
     #[... "Á@ÂÃA\"ƒ ÄÅA\"‚ ÄÆA\"\"‡"
          [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5]
     nil
     #[... "ÁÂ\"† ÁÃ\"?… Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]
  ])

I do not see why should it be stuck...

@LukeHoersten, @sritchie, @zovt, @MichaelXavier: can you rm *.elc to remove all compiled haskell-mode elisp and try to get same output from not-compiled haskell-mode?

sritchie commented 9 years ago

I reinstalled haskell-mode from ELPA and it looks like the issue might be fixed! I haven't had the REPL hang in the last 20 minutes. Previously it would hang every few commands. We might be in business.

I deleted the ELPA package, restarted emacs, reinstalled, restarted again and everything looks good.

sritchie commented 9 years ago

I've had issues before with installing a new version of some package when an old version was still around. Emacs uses some old function definition when compiling instead of the new one, and some busted error gets locked into the compiled files.

sritchie commented 9 years ago

Nope, I was wrong. Still hanging.

((name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (#0 . "s") #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[... "Â=ƒà  @ÄÅÆÇ   @!!\"\"‡Ã @ÄÈÆÇ   @!!ÉÊ$\"‡" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[... "AƒÂÃ@!!ÄA!ˆ)ÅÆ!‡" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command (#0) #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "s") #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[... "Â=ƒà    @ÄÅÆÇ   @!!\"\"‡Ã @ÄÈÆÇ   @!!ÉÊ$\"‡" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[... "AƒÂÃ@!!ÄA!ˆ)ÅÆ!‡" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command (nil ... ... ... #1 ... ... ... ... ... ... ...) (lambda ... ...) nil setcar] [cl-struct-haskell-command (... #0 "1" 0) #[... "dbˆÂcˆdà  ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]] [cl-struct-haskell-command (nil ... ... ... #1 ... ... ... ... ... ... ...) (lambda ... ...) nil setcar] [cl-struct-haskell-command (nil ... ... ... #1 ... ... ... ... ... ... ...) (lambda ... ...) nil setcar] [cl-struct-haskell-command (nil ... ... ... #1 ... ... ... ... ... ... ...) (lambda ... ...) nil setcar] [cl-struct-haskell-command (... #0 "1" 0) #[... "dbˆÂcˆdà ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]] ...) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 691 in *course*> . #<marker (moves after insertion) at 691 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command ... #[... "Â=ƒà  @ÄÅÆÇ   @!!\"\"‡Ã @ÄÈÆÇ   @!!ÉÊ$\"‡" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[... "AƒÂÃ@!!ÄA!ˆ)ÅÆ!‡" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command ... #[... "Â=ƒà @ÄÅÆÇ   @!!\"\"‡Ã @ÄÈÆÇ   @!!ÉÊ$\"‡" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[... "AƒÂÃ@!!ÄA!ˆ)ÅÆ!‡" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command ... ... nil setcar] [cl-struct-haskell-command ... #[... "dbˆÂcˆdà   ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]] [cl-struct-haskell-command ... ... nil setcar] [cl-struct-haskell-command ... ... nil setcar] [cl-struct-haskell-command ... ... nil setcar] [cl-struct-haskell-command ... #[... "dbˆÂcˆdà  ‰A@²Ä   AA@!\"ˆÅ  ‰A@²Æ\"‡" [haskell-interactive-mode-result-end state "
" haskell-process-send-string haskell-interactive-mode-multi-line haskell-process-set-evaluating t] 4] #[... "ÆÇAA@\"…ÆAA@È\"?…6AAA@É
Ê ËO#Ì@\"ˆAA‰GC¡ˆ+ˇ" [state cursor haskell-process-prompt-regex buffer next v string-prefix-p ":q" ":quit" replace-regexp-in-string "" nil ...] 7] #[... "‰A@²Ã\"ˆÄ  \"?…Å  \"‡" [state response haskell-process-set-evaluating nil haskell-interactive-mode-trigger-compile-error haskell-interactive-mode-expr-result] 3]] ...) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command ... #[... "Á@ÂÃA\"ƒÄÅA\"‚ÄÆA\"\"‡" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "ÁÂ\"†ÁÃ\"?…Ä!‡" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #1)))
gracjan commented 9 years ago

@sritchie: Could you run the git, not compiled version? I do not think we can find more info in those binary dumps...

gracjan commented 9 years ago

The interesting part contains no information:

(current-command .
   [cl-struct-haskell-command
       ...
       #[... "Á@ÂÃA\"ƒ ÄÅA\"‚ ÄÆA\"\"‡"
       [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5]
       nil
       #[... "ÁÂ\"† ÁÃ\"?… Ä!‡"
           [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]])
sritchie commented 9 years ago

here's what I get when I kill all *.elc files. Unfortunately it doesn't look that helpful either. Seems like emacs lisp hides the lambda bodies. Checking if there's some way I can force these to print. (I'm in the #haskell IRC channel as sritchie if you're on, btw, happy to give you better turnaround time on this stuff)

((name . "course")
 (current-response-cursor . 0)
 (current-response . "")
 (command-queue
  [cl-struct-haskell-command (#0) (lambda ... ...) nil (lambda ... ... ...)]
  [cl-struct-haskell-command (... #0 "1" 0) (lambda ... ... ... ... ... ...) (lambda ... ...) (lambda ... ... ...)]
  [cl-struct-haskell-command (... #0 "1" 0) (lambda ... ... ... ... ... ...) (lambda ... ...) (lambda ... ... ...)]
  [cl-struct-haskell-command (... #0 "1" 0) (lambda ... ... ... ... ... ...) (lambda ... ...) (lambda ... ... ...)]
  [cl-struct-haskell-command (... #0 "1" 0) (lambda ... ... ... ... ... ...) (lambda ... ...) (lambda ... ... ...)]
  [cl-struct-haskell-command (... #0 "1" 0) (lambda ... ... ... ... ... ...) (lambda ... ...) (lambda ... ... ...)])
 (inferior-process . #<process course>) (is-restarting)
 (current-command . [cl-struct-haskell-command
                     (#0) (lambda ... ...) nil (lambda ... ...)])
 (suggested-imported)
 (sent-stdin)
 (evaluating)
 (session (name . "course")
          (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion)
                             at 300 in *course*>)
          (next-error-locus)
          (interactive-buffer . #<buffer *course*>)
          (current-dir . "/Users/sritchie/code/haskell/course/")
          (target . "")
          (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853")
          (cabal-dir . "/Users/sritchie/code/haskell/course/")
          (process (name . "course")
                   (current-response-cursor . 0)
                   (current-response . "")
                   (command-queue [cl-struct-haskell-command ... ... nil ...] [cl-struct-haskell-command ... ... ... ...] [cl-struct-haskell-command ... ... ... ...] [cl-struct-haskell-command ... ... ... ...] [cl-struct-haskell-command ... ... ... ...] [cl-struct-haskell-command ... ... ... ...])
                   (inferior-process . #<process course>)
                   (is-restarting)
                   (current-command . [cl-struct-haskell-command ... ... nil ...])
                   (suggested-imported)
                   (sent-stdin)
                   (evaluating)
                   #1)))
sritchie commented 9 years ago

Boom, adjusted the print depth and level and now I get this:

((name . "course")
 (current-response-cursor . 0)
 (current-response . "")
 (command-queue [cl-struct-haskell-command (#0) (lambda (state) (if (eq system-type (quote windows-nt)) (haskell-process-send-string (car state) (format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" (haskell-session-cabal-dir (haskell-process-session (car state))))) (haskell-process-send-string (car state) (format ":!cd %s && %s | %s" (haskell-session-cabal-dir (haskell-process-session (car state))) "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x")))) nil (lambda (state response) (if (cdr state) (progn (let ((tags-file-name (haskell-session-tags-filename (haskell-process-session (car state))))) (find-tag (cdr state))))) (haskell-mode-message-line "Tags generated."))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #5))) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #5))) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #5))) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #5))) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #5))) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) #4))) (lambda (s) (haskell-process-send-string (cdr s) ":type isHappy")) nil setcar] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) #4))) (lambda (s) (haskell-process-send-string (cdr s) ":type isHappy")) nil setcar] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) #4))) (lambda (s) (haskell-process-send-string (cdr s) ":type isHappy")) nil setcar]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (#0) (lambda (state) (if (eq system-type (quote windows-nt)) (haskell-process-send-string (car state) (format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" (haskell-session-cabal-dir (haskell-process-session (car state))))) (haskell-process-send-string (car state) (format ":!cd %s && %s | %s" (haskell-session-cabal-dir (haskell-process-session (car state))) "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x")))) nil (lambda (state response) (if (cdr state) (progn (let ((tags-file-name (haskell-session-tags-filename (haskell-process-session (car state))))) (find-tag (cdr state))))) (haskell-mode-message-line "Tags generated."))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #2) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #2) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #2) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #2) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (((name . "course") (next-error-region #<marker at 300 in *course*> . #<marker (moves after insertion) at 300 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") #2) #0 "1" 0) (lambda (state) (goto-char (point-max)) (insert "
") (setq haskell-interactive-mode-result-end (point-max)) (haskell-process-send-string (cadr state) (haskell-interactive-mode-multi-line (car (cdr (cdr state))))) (haskell-process-set-evaluating (cadr state) t)) (lambda (state buffer) (if (and (string-prefix-p ":q" (car (cdr (cdr state)))) (string-prefix-p (car (cdr (cdr state))) ":quit")) nil (let* ((cursor (car (cdr (cdr (cdr state))))) (next (replace-regexp-in-string haskell-process-prompt-regex "" (substring buffer cursor)))) (haskell-interactive-mode-eval-result (car state) next) (let* ((v (cdr (cdr state)))) (setcdr v (list (length buffer)))) nil))) (lambda (state response) (haskell-process-set-evaluating (cadr state) nil) (if (haskell-interactive-mode-trigger-compile-error state response) nil (haskell-interactive-mode-expr-result state response)))] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #3 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) #1) (lambda (s) (haskell-process-send-string (cdr s) ":type isHappy")) nil setcar] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #3 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) #1) (lambda (s) (haskell-process-send-string (cdr s) ":type isHappy")) nil setcar] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #3 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) #1) (lambda (s) (haskell-process-send-string (cdr s) ":type isHappy")) nil setcar]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) (lambda (state) (haskell-process-send-string (car state) (if (string-match "^[A-Za-z_]" (cdr state)) (format ":info %s" (cdr state)) (format ":info (%s)" (cdr state))))) nil (lambda (state response) (if (or (string-match "^Top level" response) (string-match "^<interactive>" response)) nil (haskell-mode-message-line response)))]) (suggested-imported) (sent-stdin) (evaluating) #1)))
sritchie commented 9 years ago

Not sure if it's related to this bug, but ever since upgrading to the latest haskell-mode (the 3-30 build on git) I'm getting freezes almost every other character. Not sure what process is hogging. These go away if I kill the interactive process.

sritchie commented 9 years ago

It seems like before, the main buffer would keep running when the repl locked. Now if the repl locks, the main buffer gets stuck as well.

This issue DOES go away if I back off to 13.12 from melpa-stable.

sritchie commented 9 years ago

I'm also not providing that much info, but I did enable toggle-debug-on-quit, which gave me a trace when I had to kill the process that was stopping up my Haskell buffer:

Debugger entered--Lisp error: (quit)
  accept-process-output(#<process course> 1)
  haskell-process-queue-flush(((name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (#0 . "Num") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "square") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\302=\203\303    @\304\305\306\307   @!!\"\"\207\303 @\304\310\306\307   @!!\311\312$\"\207" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[(state response) "A\203\302\303@!!\304A!\210)\305\306!\207" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 282 in *course*> . #<marker (moves after insertion) at 282 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command ... #[... "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #4))) (lambda (s) (haskell-process-send-string (cdr s) ":type square")) nil setcar]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 282 in *course*> . #<marker (moves after insertion) at 282 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (#0 . "Num") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "square") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\302=\203\303    @\304\305\306\307   @!!\"\"\207\303 @\304\310\306\307   @!!\311\312$\"\207" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[(state response) "A\203\302\303@!!\304A!\210)\305\306!\207" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #3 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command ... #[... "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #1) (lambda (s) (haskell-process-send-string (cdr s) ":type square")) nil setcar]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #1))))
  haskell-process-queue-sync-request(((name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (#0 . "Num") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "square") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\302=\203\303 @\304\305\306\307   @!!\"\"\207\303 @\304\310\306\307   @!!\311\312$\"\207" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[(state response) "A\203\302\303@!!\304A!\210)\305\306!\207" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 282 in *course*> . #<marker (moves after insertion) at 282 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") #1 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command ... #[... "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #4))) (lambda (s) (haskell-process-send-string (cdr s) ":type square")) nil setcar]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) (session (name . "course") (next-error-region #<marker at 282 in *course*> . #<marker (moves after insertion) at 282 in *course*>) (next-error-locus) (interactive-buffer . #<buffer *course*>) (current-dir . "/Users/sritchie/code/haskell/course/") (target . "") (cabal-checksum . "6b98f5fe887cf741a9a9382f63a93853") (cabal-dir . "/Users/sritchie/code/haskell/course/") (process (name . "course") (current-response-cursor . 0) (current-response . "") (command-queue [cl-struct-haskell-command (#0 . "Num") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "a") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "square") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0 . "x") #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]] [cl-struct-haskell-command (#0) #[(state) "\302=\203\303    @\304\305\306\307   @!!\"\"\207\303 @\304\310\306\307   @!!\311\312$\"\207" [system-type state windows-nt haskell-process-send-string format ":!powershell -Command \"& { cd %s ; hasktags -e -x (ls -fi *.hs *.lhs *.hsc -exclude \\\"#*#\\\" -name -r) ; exit }\"" haskell-session-cabal-dir haskell-process-session ":!cd %s && %s | %s" "find . -name '*.hs' -print0 -or -name '*.lhs' -print0 -or -name '*.hsc' -print0" "xargs -0 hasktags -e -x"] 7] nil #[(state response) "A\203\302\303@!!\304A!\210)\305\306!\207" [state tags-file-name haskell-session-tags-filename haskell-process-session find-tag haskell-mode-message-line "Tags generated."] 3]] [cl-struct-haskell-command (nil (name . "course") (current-response-cursor . 0) (current-response . "") #3 (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command ... #[... "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[... "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #1) (lambda (s) (haskell-process-send-string (cdr s) ":type square")) nil setcar]) (inferior-process . #<process course>) (is-restarting) (current-command . [cl-struct-haskell-command (#0) #[(state) "\301@\302\303A\"\203\304\305A\"\202\304\306A\"\"\207" [state haskell-process-send-string string-match "^[A-Za-z_]" format ":info %s" ":info (%s)"] 5] nil #[(state response) "\301\302\"\206\301\303\"?\205\304!\207" [response string-match "^Top level" "^<interactive>" haskell-mode-message-line] 3]]) (suggested-imported) (sent-stdin) (evaluating) #1))) ":type square")
  haskell-process-get-type("square" identity t)
  haskell-doc-current-info--interaction(t)
  haskell-doc-show-type()
  haskell-doc-mode-print-current-symbol-info()
  apply(haskell-doc-mode-print-current-symbol-info nil)
  byte-code("r\301\302H\303H\"\210)\301\207" [timer apply 5 6] 4)
  timer-event-handler([t 0 0 500000 t haskell-doc-mode-print-current-symbol-info nil idle 0])
gracjan commented 9 years ago

@sritchie: can you disable 'stylish-haskell-on-safe', 'flycheck-haskell' and generally any automatic thing for the buffer and see if it still hangs?

gracjan commented 9 years ago

@sritchie: disable this also: haskell-doc-mode-print-current-symbol-info

geraldus commented 9 years ago

I've faced similar issue: when I type haskell code and make very short delay Emacs hangs for couple of seconds. During that hangs all I can do is wait. After a long investigation I can claim that this is because FlyCheck. Finally I have this setup:

which works flawlessly and quite smooth. I had to test almost everything mentioned above disabling to and fro, finally the last thing I disabled was flycheck-mode, and this resolved hanging issue completely (thus above combination become possible again).

Important notice: it is possible to make FlyCheck operates normally; to do that I've disabled haskell-ghc checker and «plugged—in» haskell-flycheck from Chris' repository:

(require 'haskell-flycheck)
(add-hook
 'haskell-mode-hook
 (lambda () (flycheck-disable-checker 'haskell-ghc)))
chrisdone commented 9 years ago

I think the problem with this issue is that we're lacking an isolated reproducible test-case. Failing that I don't anticipate solving it any time soon as I'm unable to reproduce these lock-ups.

geraldus commented 9 years ago

Don't mind me, now I have hangs back, and can't beat them in fast way (I mean I need to recked all that stuff again). I'll make isolated environment using docker or vagrant and see could I reproduce this behaviour there.

lukehoersten commented 9 years ago

@geraldus I think the issue you're seeing is different than what this issue is about. For example, your whole emacs is freezing while this issue #447 is about the haskell-process ceasing to respond. Emacs keeps responding.

I think I've reproduced your frozen emacs issue. It seems to be caused by company-mode for some reason. Turning company mode off alleviates all emacs freezing issues for me.

geraldus commented 9 years ago

I think the issue you're seeing is different than what this issue is about

First of all excuse me for off topic in this case

@LukeHoersten your guess seems to be right. CompAny works well when ghc-mod works properly, and it hangs when ghc-mod gives unusual output. This is related to version of ghc-mod I'm using, see https://github.com/kazu-yamamoto/ghc-mod/issues/460. What is the best place to continue conversation of my issue?

MichaelXavier commented 9 years ago

@chrisdone I don't think anyone in this thread is trying to drag their feet about a reproducible test case. I won't speak for others but for myself I don't know how to boil this complicated integration into a test case. The best I can say is that it happens frequently enough that I'd have no trouble catching the problem in the act and dumping state, but this thread may need more guidance to whittle this down. What steps would you take if you were experiencing this issue like we are?

geraldus commented 9 years ago

Sorry guys, there was some unforeseen circumstances which make me out of business for some time. Now I facing «No space left on device» with my docker, I hope I will be able handle this tomorrow and finish image for Emacs + Haskell-mode testings.

gracjan commented 8 years ago

Lets declare defeat here.