Functions for better interoperability between fif and a
clojure(script) client.

Used for the standalone fif executable.

Implementation of programmable repl. Useful for implementing fif
outside of a standard input/output environment.

Main implementation of IStackMachine

A fif server uses a stack-machine with a set of *sessions*, which are
separate stack-machine instantiations.

Represents dynamic bindings used between the server and repl
instances for individual thread management of input and output.

Represents a fif repl, which is used with the fif.server.core socket
server.

Main Stack Machine Protocol which stores state machine related
information, and stores the entirety of the language functionality.

Creating the stack machine with the standard libraries is what makes
up fif.

Functions for handling errors within the fif stackmachine.

Functions for running and evaluating fif code within a stack machine.

Used to generate stack-error exceptions.

Functions for manipulating the stack machine flags

Includes functions for creating mode functions within the stack
machine.

Stack machine functions for manipulating the scope.

Functions for manipulating the stack machine mode stash. The stash is
used by individual modes for storing information in between steps.

Includes functions for validating stack-machine word operations.

Functions for ensuring certain guarantees within the stack machine
before running operations.

Functions for realizing word functions and word variables.

Includes all of the standard library functions and modes for fif.

Mode for collecting values, and placing within a data structure

Includes the majority of clojure collection functions, which have
been ported to fif for use with the same collections.

All collection operations follow the same argument order:

Examples:
(require '[fif.core :as fif])

;; Clojure
(conj [1 2 3] 4) ;; => [1 2 3 4]

;; Fif
(fif/reval [1 2 3] 4 conj) ;; => '([1 2 3 4])

Defines the two main modes, compile-mode and function-mode, which are
used to define new word definitions, and to invoke word definitions
with their own word definition scope.

compile-mode is called when a function is first defined with
`arg-start-token`, and this compilation mode is finished upon
reaching the end of the new definition defined by `arg-end-token`.

function-mode is entered when a word definition is invoked from the
code queue.

For the if-else-then fif functionality

Allows defining words which return a constant value

Includes operations for performing basic functional programming

Functions for learning about how to use fif.

Includes IO operations for reading in fif files, or additional text
files.

Notes:

- This is not included in the fif.core/*default-stack* for security reasons.

- This is used primarily with the 'fif' commandline tool.

Standard Library Word Definitions for common operators

- Most of the functions listed were taken from the Forth standard library.

Piecewise operators allow you to re-evaluate values that are on the
stack.

This allows you to grab variables that are on the stack to be re-evaluated.

Notes:

- depends on 'apply' word function in the collectors stdlib

Notes:

- depends on 'apply' word function in the collectors stdlib

Includes operations which are used primarily in a fif repl.

word symbols that will be reserved, with prevention when being
generating certain word definitions.

Provides fif with a dash '-' separated argument processing mode. This
performs a reach-ahead to word definitions, and stores the results
in a stash which can be accessed by a word function.

Includes stack functionality that can manipulate the entire stack
machine.

Includes the variable-mode, for creating mutable variables within a
stack machine.

Implements a container system which allows for retrieval of values
within a hierarchy of containers, where each container is a separate
scope.

Functions for manipulating stashes, not to be confused with stacks.
A stash in this case is collection of containers. The containers are
sequenced fifo-style, with operations performed on the latest
container pushed into the collection of stash containers.

Includes functions for manipulating tokens/symbols.