"Hell Is Other REPLs": How does IEx compare?

I just finished reading Hell Is Other REPLs in Colin Okay’s SAVE-LISP-OR-DIE series. It’s an interesting look at Common Lisp, with perceptive comparisons to various other languages.

The article closes with this summary, making me wonder how IEx compares to the Common Lisp REPL:

… true interactive development is programming such that

  1. your program never crashes
  2. because it enters an interactive debugger
  3. where you never lose program state
  4. unless you choose to do so
  5. after a thorough inspection of state
  6. including the call stack
  7. and after you have tinkered, recompiled functions, and edited objects
  8. and after you have tried restarting the computation
  9. all while the live program is running, possibly remotely.

AFAIK, IEx supports most (if not all) of this. However, I don’t feel qualified to make a detailed assessment. I’d also be interested to hear folks’ thoughts on REPL capabilities and features that the list doesn’t mention.

Would anyone like to offer some clues and/or comments?

1 Like

One thing I miss from Ruby is something like Ruby Pry Rescue

There is an awesome presentation, and at this point, he explains how you can use it to just catch any error and fix it dynamically, as one can do in CL.

1 Like

Having played with Clojure enough last year to be mildly dangerous (as I am now with Elixir!), the biggest thing which jumps out at me is more tool ergonomics than fundamentals. The Clojure REPL (similarly to other LISPS) is typically linked directly to your editor, such that you can hit a keystroke and instantly eval any changes into the running application, with output into the editor buffer (either as a transient overlay for info, or to a comment for further use). It’s hard to explain how smoothly interactive this makes the development process feel.


I really missed this coming to Elixir. I’m not sure if it just hasn’t been implement yet or if there’s something about Elixir/BEAM that precludes it.

I don’t know either, but if you look at the scope of nRepl, CIDER etc, it’s a lot of work!

1 Like

The up arrow should remember multiline input for goodness sake.

Go use Julia, and type this:

julia> function add(x, y)
   x - y
julia> add(4, 3)

Now, go back and edit the add function to fix it. It’s straightforward.

It is not so in elixir (or python, or ruby, so we’re not alone but that is no excuse to not do better).

Also, I kind of want naked functions in the repl context. That’s probably too much to ask but it could be done by having a “IEx.Repl” module that is “imported” into the context and the def macro in the IEx scope triggers a recompilation of this module


I’m happy to see that we’re getting some interesting suggestions. Assuming that nobody brings up any show-stopper objections, please consider turning these ideas into formal issues for IEx.

Elixir interaction mode for emacs would certainly be appreciated.

I never ever used the native shell of any programming language if there was a corresponding emacs mode available.

Oops – there seems to be Alchemist, so I’ll check that out…

That would be so awesome. I work around it by using clipboard history/manager.

I’m super glad they recently allowed pipelining without requiring parens.

If we’re making requests, I would like a dynamic prompt. Seems easy to allow an anonymous function as a prompt, rather than an interpolated string. Use case is we have a multi-tenanted app and it would be nice to see what tenant you’re set to in the prompt:

iex(1)> Tenant.set("foo")
iex(1)[foo]> Tenant.set("bar")