preplish VS vim-slime

> what's wrong with that?

Why nothing at all, of course. A REPL need not be more than a way to test and explore syntax, functions, and logical structures.

> the user experience is REPL-ish and it can help some people learn the _basics_ of the language

PREPLISH exists for Perl ^_^

https://github.com/viviparous/preplish

If this is for testing of syntax or of trivial code, it sounds like a good use-case for running a local REPL. (Example: https://github.com/viviparous/preplish)

This is a simple REPL project and the readme lists other Perl REPLs.

https://github.com/viviparous/preplish

Perl's concise syntax makes working in a REPL a pleasure. Python has a REPL but the design of the language makes it expand both in length (for loops) and in width (tabs).

I am a recent convert to working in a REPL first to test programming ideas.

I made this solution for some of my simple data wrangling: https://github.com/viviparous/preplish

I tried the module it in a Perl REPL (https://github.com/viviparous/preplish) and got the following ravings that are worthy of a US loony politician:

I agree with you that the immediate start-up and feedback is a great benefit to the coder. This is why I dislike complex, Rube-Goldbergian REPL systems.

There is a use-case for a throw-away interaction with a REPL. For example, how does $builtinFuncX work, or how would $data best be imported into a structure?

A REPL can also be a good initial approach to a more ambitious problem. In this case, a REPL can be good for focus and discipline.

If the second case is going to answer your concern and be constructive, it's necessary to be able to build the code for sharing and cleanly export the code for re-use.

I've had success tackling challenges using REPLs for Python and Perl [1] in both ways. But no tooling is going to solve the problem of a sloppy teammate who claims success just because "it compiles" and "it works on my box". A person who knows how to build good tooling goes further.

[1] https://github.com/viviparous/preplish

It is Jupyter is a Rube-Goldbergian nightmare. Python is a memory hog. There are better solutions, to be sure.

A simple REPL is all that's needed to both do A-type and B-type data exploration. (I won't use the term "data scientist", it's an exaggeration in most cases.)

Python has a REPL, R has a REPL, Perl has PDL and both a simple REPL (https://github.com/viviparous/preplish) and a more complex one (https://metacpan.org/pod/Reply).

Jupyter should not be used as an IDE because it is the wrong tool for development. A-type data explorers just want a painless UI and may not care much about the horrible agglutination of incomplete/slow/broken solutions that Jupyter represents.

https://github.com/jpalardy/vim-slime

you can have a REPL in nvim/vim/tmux/screen/another terminal/or any other window , and send regions from your vim buffer to that repl

For vim users, check out vim-slime[1]. It's really changed my workflow! It can work for any language that uses a REPL, including bash/shell. Combined with tmux, it is an amazing and (in hindsight) obvious tool. I honestly can't imagine myself going back to not having it now.

[1]: https://github.com/jpalardy/vim-slime

For splitting the terminal you could try either toggleterm or tmux. If you want to send things from one tmux pane to another, then you can use slime. For a toggle-able filetree, you can use nvim tree.

I use vim-slime. It works really well in tmux. https://github.com/jpalardy/vim-slime. Just blocks of code as cells

This is yet another plugin to capture text from the current buffer and send it to a tmux pane. I was using https://github.com/jpalardy/vim-slime previously, and wished I could just set sensible defaults for where to send text. Also, I wanted to create my first Neovim plugin! I have to say, after writing a bit of Vimscript in the past, the Neovim Lua API makes me a much happier camper.

I use slime (which sends code to tmux panes), tmux (of course) and ipython for this. For example, the code I sent to ipython was with a simple keybinding ...

If I understand correctly, what you need is a combination of vim, tmux, ipython and vim-slime.

REPL??? Do you have a very-easy-to-use way of running and testing your code? From vim-slime to nvim sniprun to autocommands with the built in terminal, to an external repl like ptpython (for python obviously). iron.nvim and conjure are two other neovim repl plugins. There are many ways of running the code that you're working on, and having something that makes this really easy for you is pretty essential. (sometimes I use inotifytools on linux to literally just run the script every time I save it.)

For the record/list, there's also: - https://github.com/hkupty/iron.nvim and - https://github.com/jpalardy/vim-slime

However, if you're coding in an interpreted language like python, R, bash, etc., then there is one plugin which you are likely to find helpful. That's vim-slime.