sniprun

To make a language support REPL-like behavior (persisting variables across runs) in sniprun, you must implement the ReplLikeInterpreter trait instead of the standard Interpreter trait.

There are two primary strategies:

1. State Persistence: Using language-specific 'quirks' to save and load variables to/from a file (e.g., Python's klepto module).
2. Pipe-based Runner (Recommended): Using a named pipe (FIFO) to communicate with a live, running interpreter process. The code sent by sniprun is piped into the FIFO, and the interpreter's output is written to a file. Sniprun monitors this file for specific 'landmarks' to determine when execution starts and ends.

Note: You should disable interpreter prompts (e.g., setting sys.ps1 and sys.ps2 to "" in Python) to prevent them from polluting stdout.

Sniprun supports languages at different levels of depth. Understanding these levels helps you know what kind of code you can run:

• Unsupported/Untested: May work at a 'bloc' level using community configurations for the generic interpreter.
• Line: Only single lines of code work (e.g., print([x**2 for x in range(10)])). Variables defined elsewhere will not be recognized.
• Bloc: You can select any semantically correct piece of code (independent of indentation) in visual mode and run it.
• Import: Supports external imports, allowing you to test code blocks that depend on external libraries.

Note: Future/unsupported features include 'File' (recursive variable/function finding) and 'Project' (automatic project root detection and relative import handling).

Sniprun may encounter issues with programs that:

• Manipulate stdout or stderr directly.
• Require input from stdin.
• Print excessive lines or incorrect UTF-8 characters.
• Access files using relative paths. Because Sniprun's current working directory is typically ~/.cache/sniprun, relative imports or file access may fail.

The Lua_nvim interpreter operates in a pseudo-REPL (Read-Eval-Print Loop) mode that cannot be disabled. This means that variables and state persist between consecutive sniprun executions. Because it runs within Neovim, you have access to the standard Neovim Lua API functions during execution.

When running Lua scripts line-by-line or block-by-block, the interpreter maintains the state of previously defined variables.

a = 4 
b = 6
print(a+5) -- <- 9

a = 0

print(a + b) -- <- 6

When repl_enable = {'Mathematica_original'} is active, Sniprun launches a WolframKernel instance in the background.

Key constraints and behaviors:

• Single Instance: The REPL session is only usable by one Neovim instance. Attempting to use it in multiple instances will likely cause crashes.
• Lifecycle: The session closes when the last Neovim instance quits.
• Startup: The very first SnipRun command executed in a Neovim instance is used solely to start the REPL kernel; the actual code selection is discarded. You must re-run your selection after the kernel has started.
• Output Suppression: Just like in standard mode, suffix expressions with ; to suppress output. It is strongly recommended to suffix Plots with ; to avoid unwanted output behavior.

When using the Sniprun API, be aware of the following:

• Buffer Coupling: Sniprun is tightly coupled to the current Neovim buffer and instance.
• Interpreter Behavior: While there should be no dependencies for non-REPL or Bloc-Level interpreters, REPL-capable or Import-level (or higher) interpreters may attempt to fetch information from the current buffer. Ensure your environment accounts for this if running in non-standard contexts.

The FSharp_fifo interpreter uses a REPL (Read-Eval-Print Loop) pattern based on named pipes (FIFOs) to improve performance.

When a FIFO-based interpreter receives its first run command, it forks to the background and executes an initialization script (ressources/init_repl.sh). This script sets up a named pipe to act as the communication channel between Sniprun and the language process.

Note: Currently, the REPL mode for dotnet fsi is broken because dotnet fsi is sensitive to how its stdin is managed via pipes. If you are using a different language that supports a stable interactive mode (similar to python -i), the REPL mechanism should function correctly.

To install Sniprun using a plugin manager (like lazy.nvim), use the following configuration:

{ "michaelb/sniprun", build = "sh install.sh" }

Once installed, you can use these core Neovim commands:

• :SnipRun: Executes the current code snippet (e.g., a visual selection or current line).
• :'<,'>SnipRun: Executes the selected range in visual mode.
• :SnipInfo: Displays information about the current snippet.