RFC: Add session option

[laburnumT]

Adds a session option to codeblocks so previous results can be used.

To check that a command is done running, we wait for an eof_token to appear. This allows us to not cut off commands with output early, but also doesn't rely on using sleep.

[laburnumT]

This is an RFC for adding session support to vim-medieval. It's currently quite
hacky, because repl's aren't always accessed the same way. But that's why it's a
first draft.

It currently has some checks in there for python (because that's what I use in
markdown for the most part).

This should probably be integrated into g:medieval_langs, or a new config
variable, but I just wanted to know if there is any interest in functionality
like this before I do that work.

[laburnumT]

The main problem this is trying to address is where something is either costly
to run or not idempotent. As a rather stupid example:

<!-- session: example -->
```python
import random
import time

time.sleep(5)
x = 42
```

<!-- session: example -->
```python
print(random.randint(1, x))
```

Using require here would make the print block always take 5 seconds, whereas
with a session it would run instantly (as long as the first code block has been
run at least once)

[gpanders]

The main problem this is trying to address is where something is either costly to run or not idempotent. As a rather stupid example:

<!-- session: example -->
```python
import random
import time

time.sleep(5)
x = 42

print(random.randint(1, x))

Using require here would make the print block always take 5 seconds, whereas with a session it would run instantly (as long as the first code block has been run at least once)

The use case makes sense to me. Though I think you should already be able to solve this today with no changes.

For example, something like this:

<!-- target: a -->
```python
import random
import time

time.sleep(5)
x = 42
print(f"x={x}")
```

<!-- name: a
```python
```
-->

<!-- require: a -->
```python
import random
print(random.randint(1, x))
```

I understand this is a contrived example, but the basic idea is: in the first (expensive) block, write code to a temporary block (a in this case) that re-uses the expensive results of the computation. Then you can require that temporary block in the final block.

Note that the a block is wrapped inside the HTML comment so that it won't be visible in any rendered HTML output.

[laburnumT]

That would probably solve a lot of cases. But I feel like it might run into
problems with something like Haskell or some other language. But even in python
this does run into problems with classes that aren't printable (don't have a
dedicated str method).

Something like the following wouldn't work:

<!-- target: a -->
```python
class Example:
    def __init__(self, a, b):
        self.a = a
        self.b = b


example = Example(1, 2)
print(f"example={example}")
```

<!-- name: a
```python
example=<__main__.Example object at 0x723d8c290d70>
```
-->

<!-- require: a, target: out -->
```python
print(example.a)
```

<!-- name: out -->
```python
  File "/tmp/vqFx8sb/13", line 1
    example=<__main__.Example object at 0x723d8c290d70>
            ^
SyntaxError: invalid syntax
```

It also seems rather cumbersome to have to add all the print statements one
might need.

[laburnumT]

Apologies if you are on holiday or otherwise occupied. In which case please
ignore this.

Just wanted to see if there were any more thoughts on this RFC.

[gpanders]

As I said earlier the use case makes sense to me and I'm not opposed to the feature on principle but the PR needs some work.

Most of the comments I left are easily actionable, just a few small refactors. But there are some missing design points still, in particular how to map the "session" paradigm to each individual language without hard coding special cases into the source code.

[gpanders]

These two functions are identical, let's consolidate (name it s:sessiondata since it's only used for sessions)

[gpanders]

Follow the conventions of the repo:

Suggested change

	function! s:session_read(key, lines) abort
	function! s:sessionread(key, lines) abort

[gpanders]

Why do you have an exit callback for Nvim but not Vim?

Let's rename this s:sessionexit and re-use it for both Nvim and Vim (use a lambda if needed, look at the existing pattern in s:jobstart as a reference)

[gpanders]

Suggested change

	function! s:eval_session(lang, session_name, block, cb) abort
	function! s:evalsession(lang, session_name, block, cb) abort

[gpanders]

We're not going to hard code languages in here (we have to do it for cmd to work around Windows wonkiness and even then I tried to avoid it). Let's find a way to make this work that is language agnostic and doesn't require special cases.

[gpanders]

Use exists('*jobstart') instead of has('nvim') (look at s:jobstart as a reference) and extract this entire block into a function s:sessionstart.

[gpanders]

Similar comment to earlier, we should not hard code language support here. And even then this is wrong, using echo for the else branch won't work.

[gpanders]

Follow the pattern of s:jobstart: make a function s:chansend that encapsulates the platform differences between Nvim and Vim and use exists('*chansend') instead of has('nvim')