Flow is a minimalistic, (trying to be) bloatfree Unix-style shell written in Rust. It embeds a lightweight Lisp-inspired interpreter for shell scripting, with almost zero external dependencies (only glob is imported). Flow combines familiar POSIX command execution with the power of S-expressions for scripting.

If you don't have rust & cargo installed, I suggest you follow the guide for installation via rustup (optional).

Then clone the repository and simply build & run using cargo run.

• Posix style command execution
• Lisp like syntax (not turing complete at the moment)

Entering repl doesnt require any additional work aside from simply running the program binary

Syntax:

./PathToTheFlowBinary

Example (in my setup I have exported the binary to PATH):

flow 

Pass one or more .flw script files as arguments, they run in the order provided:

Syntax:

./PathToTheFlowBinary arg1 ... pathToFile ... argN 

Example (in my setup I have exported the binary to PATH):

flow ./script1.flw ./script2.flw

Include the debug flag anywhere among your arguments to enable tracing. Flow will output:

1. FUNCTION_ENTER - function name, module, and argument values upon entry.
2. FUNCTION_INFO - mid-execution debug messages
3. FUNCTION_EXIT - return values upon exit

Syntax:

./PathToTheFlowBinary arg1 ... debug ... argN 

Example (in my setup I have exported the binary to PATH):

flow debug

Use the rcloc flag as a command line argument to specify a custom path:

Syntax:

./PathToTheFlowBinary arg1 ... rcloc pathToFlowRcFile ... argN 

Example (in my setup I have exported the binary to PATH):

flow rcloc ./$HOME/.config/flowConfig/

The .flowrc file is nothing more than a Flow script that is run automatically before any custom command execution, every configuration command/option can be executed also through all execution methods such as the repl.

Flow reserves these environment variables for its configuration:

1. PS1 - lets you define a custom prompt.
2. HISTLOCATION - lets you define a custom location for the .flow_history file

Single-line comments start with `;` and continue to end of line:

Syntax:

; The desired comemnt goes here...

Example:

(exec ; First comment

      (
       ls |
       ; Second comment
       grep *.rs
      )
)

There are two types of variables supported:

1. Environment variables
2. Local runtime variables

This mode of command execution is almost identical to well known shells like bash.

The syntax goes as follows:

command_name arg1 arg2 arg3 ...

Example:

grep #someVariable

Wrap commands in Default Shell Mode in an S-expression with `exec`.

The syntax goes as follows:

(exec (command_name arg1 arg2 arg3 ...))

Example:

(exec (
       echo
          #someVariable
      )
)

In the case of Flow, globbing follows the POSIX 2 standard and is identical to using globs wildcard matching, so for more info please refer these manpages.

Example:

(exec ( ls *.md))

Use `|` to pipe stdout to stdin of the next command. Pipelines in Flow are identical to `bash`.

Syntax: The syntax goes as follows:

(exec ( command1_name arg1 arg2 arg3 ... | command2_name arg1 arg2 arg3 ... | ... ))

Example:

(exec ( ls *.md | grep #desiredFiles ))

The redirection of inputs or outputs is done similarly to other well known posix shells, for more info please refer to documentation for bash.

The major difference is that in flow (at this time) only one redirection per command is allowed.

Example:

(exec ( grep Something < textOfSomethings.txt | grep SomethingSpecial > textOfSomethingsSpecial.txt ))

; another command run in default mode
ls ?.txt &> listOutput.txt