There are some scripts that I find convenient to code in elisp, and I like to be able to run these with little startup time.
The natural solution is to use `emacs --batch --eval` together with `server-eval-at` to reuse an already loaded server, but this solution needs a lot of throwaway servers already started and a load balancer. (Is there a Jupyter kernel for elisp? I already have a prototype server (
https://github.com/NightMachinary/JupyterGarden) that starts throwaway Jupyter kernels and load-balances requests to them.)
If the server could just fork, eval the request, return it, and die, everything would be easy and painless.
The fork API could be:
```
(let-fork ((some_val (expensive_compute)) ...)
(lambda()
(message "Computed: %s" some_val)))
```
Where emacs forks for every binding, and computes the results, and finally, asynchronously calls the supplied callback function with all of the bindings available, similar to a closure.
I am sure there are better API designs, but my point is that this fork API should be very easy and work with synchronous third-party code, just like a shell (or GNU Parallel). Parallelism via multiprocessing should be easy and painless.
The third-party packages for parallelism that I have skimmed, start a fresh emacs instance, and do not fork, which is useless, as all the needed data and behavior needs to be manually reloaded by the user.
PS: Please use reply-to-all, I am not currently subscribed to the list. Thank you.