The background to this is that I’ve (a) recently been doing some Clojure and am slightly addicted to the REPL-connected editor, and (b) I’m a total Elixir beginner (1 week in), so all my coding is at this stage “exploratory” (playing with examples from what I’m reading, trying out Kernel functions, etc).
Here’s what I’ve come up with so far:
iex: fine for one-liners, but a bit clumsy for anything more, and I’d much rather use an editor (and preferably the same editor I would use for real code)
iex -S mix, then calling on functions in files, reloading after edits: better, but still more friction than I’d like
- via unit tests, writing small tests for the exploratory code & running
mix test. A variation here is to use
fswatch to run tests on every file save, but I haven’t got this working yet.
- again via unit tests, but triggering tests from the editor (in my case using GitHub - adamzapasnik/vscode-elixir-test-explorer: VSCode Elixir test explorer).
The final one above seems the most fluent approach so far, definitely workable, though ideally I’d like not to have to write tests for this kind of very transient exploratory code.
Well, you can start the “REPL-like” server that will receive the code, and then will use
Code.eval_string/3 to execute whatever you throw at it. It will provide similar experience to the SLIME.
About unit testing, what I am using is
entr. So you need to list all files in your project (I am using
rg -l -telixir '', but you can use
git ls-files instead) and then make it to output name of the changed file
entr echo /_ that will pass the changed files to
mix test --listen-on-stdin --stale. So whole CLI will look like:
rg -l -telixir '' | entr echo /_ | mix test --listen-on-stdin --stale
Now it will changed tests on each save.
Maybe you will find exsync and mix-test.watch useful.
Thanks for the options, @hauleth & @Marcus. For now I think unit tests with a watch are going to be the best approach. I don’t want to spend much time on tooling for now - learning Elixir & Phoenix will be enough cognitive load
Would like to look into the option of sending selected code from the editor to be eval’d at a later stage though.
I just finished going though a Common Lisp book (Gentle Introduction to Symbolic Programming) and really like the repl driven development. I also learned some Emacs along the way and that’s the editor I am using to learn Elixir. Currently going through the book Programming Elixir >= 1.6
Looking for a similar learning/development approach in elixir, where I code in the editor and verify the code is correct by evaluating the text in the editor, the text is evaluated against an elixir repl. This is very handy because there are times where I just want to check if the code is correct without leaving the editor.
Here are the tools/packages I am using:
Emacs Packages for elixir:
- inf-elixir: GitHub - J3RN/inf-elixir: An Emacs plugin for interacting with an Elixir REPL
- lsp-mode: Elixir - LSP Mode - LSP support for Emacs
- elixir-mode: GitHub - elixir-editors/emacs-elixir: Emacs major mode for Elixir
If you need a detailed setup, let me know, I can push it to a github repo.
Nice. Just what I would want if I used emacs. It’s one of the missing parts of the elixir ecosystem more widely.
If I was starting out and wanting to play around with code, LiveBook (https://livebook.dev/) would probably be my #1 choice now. Instant feedback, nice formatting etc.
Agreed, it’s terrific. Not exactly the same as using your own REPL-linked editor (different keybindings etc), but with lots of other great possibilities.
This might be what you meant by “reload” but just in case: if you haven’t found it
r/1 In IEx will let you recompile a module on the fly, i.e.
r(MyProject.MyModule). Beats terminating and restarting IEx!
At one point I had a hacked together VS Code extension that let you recompile the current file you were editing in an attached IEx session but I never followed through to ship it.
I do know about
r/1 now but the question was a while back and I have no idea whether I did or not back then (or whether that was what I meant by ‘reload’). So thanks from my erstwhile self!
Ironically (or sadly from this perspective) I’m doing more with Rust right now than Elixir, so I’m even further distant from REPLy goodness.