What about a REPL?

[epage]

In my Learnability of Rust blog post, I passed on REPL as requiring a lot more exploration before they would become useful and that a rust script solution would get us most of the benefits faster.

While I'm not ready to fully look into REPLs, I figure it'd be good to have a place to capture thoughts on them

[epage]

A recent hackernews post has a lot of good input

From What Makes a Good REPL

• Good REPL gives you
  • A smooth transition from manual to automated
  • A REPL lets you improvise
  • A REPL lets you write fewer tests, faster
    • There have been times with clap where I just wanted to quickly iterate on various inputs to see characterize the behavior to see if it made sense.
  • A REPL makes you write accessible code
• In the finer details, some interesting notes
  • Outputting values which can easily be translated to code
    • I think errors are the one exception where it can make sense to Display them
  • Being editor-friendly

[epage]

Where is the line between REPL vs a Notebook? Should we focus on one or the other? A dedicated notebook or Jupyter?

[epage]

I think ghci is one of the best repls out there:

• :type and :info

• :doc

• Debugger + breakpoints

• :print :sprint for understanding laziness

• Can run shell commands with :!

• Can set different compilation flags for the loaded code vs the repl session.

• Can define your own repl commands

I use ghci for developing standalone modules, running HTTP servers, and running unit tests.

The biggest thing I wish it had was something like chez scheme's trace, which causes it to print out a function with its arguments every time it is called.

and a reply

I like GHCi, but it's definitely missing some things if we're talking about using a REPL for development rather than just experimentation (which is a valuable thing itself).

The two biggest things, I think, are:

1. GHCi allows rebinding symbols, which is great, but it doesn't have good mechanisms for propagating that change. Haskell being Haskell, I don't really expect change local binding to propagate to everywhere that binding has been used. But it would be great if I could point at an identifier I've declared and say "redefine everything that was used to get here".

2. The path from REPL to source code in a file is very manual. I often find myself copying code out of my history, and have to manually remove bindings that I've shadowed since.

The tooling that it does provide, though, is really great :)

https://news.ycombinator.com/item?id=24588453

[epage]

Low level desired features

• Syntax highlighting or code and returned values
• multiline editing
• auto-completion
• bracketted paste
• My personal experience is that it would be great if REPL can provide some quick references for APIs, etc.
• copy-paste of code with spaces must work
• decent history handling (arrows to go up and down, Ctrl+R to search, it could be better with a fish-shell-like history handling)
• Reuse results (_ variable)
• source code and object exploring (in Ruby pry, something.source returns the source of the code)
• Integration with rust-script (python -i)

See

• https://pypi.org/project/ptpython/
• https://news.ycombinator.com/item?id=32747088

[epage]

Past discussions

• https://github.com/rust-lang/compiler-team/blob/master/content/minutes/design-meeting/2019-11-29-repl-meeting.md
  • Modifications to rustc for the Rust REPL rust-lang/compiler-team#213
  • Building a REPL on top of miri rust-lang/miri#511
• implement a proper REPL rust-lang/rust#9898
• implement a proper REPL rust-lang/rfcs#655
• https://internals.rust-lang.org/t/first-class-support-for-interactive-use-in-the-language/20803

[epage]

Prior art for compiled REPLs

• reple
• evcxr
• irust

[epage]

A "mini-notebook" might better fit the compilation model of rust

• https://ianthehenry.com/posts/my-kind-of-repl/
  • https://news.ycombinator.com/item?id=36600639
• https://github.com/darius/halp
• http://anggtwu.net/eepitch.html
• runme
• livebook
• nota

[ggggggggg]

Rust should have a reactive notebook to resolve the issues of redefinition and of hidden state. Two successful examples are Pluto.jl for julia and Marimo for python.