NAME

       storm - a language system for extensible languages

SYNOPSIS

       storm [options] [-l language] [path]
                                                                      Launch an interactive REPL.
       storm [file/directory]
                                                         Import file as package, try to run main.
       storm [options] -f function
                                                                         Run a function and exit.
       storm [options] -t/-T package
                                                     Run tests in the specified package and exit.
       storm [options] -c expr
                                                           Evaluate the expression expr and exit.
       storm --server
                                                                       Start the language server.
       storm --version
                                                              Print version information and exit.
       storm --help
                                                     Print help on command-line options and exit.

DESCRIPTION

       Storm  itself  is  a  language  system  for  extensible  languages. It is bundled with two
       languages, the general purpose language Basic Storm and the syntax language for specifying
       context-free  grammars.  Normal usage of Storm is typically confined to the lanugage Basic
       Storm.

       The easiest way to get started with Storm is to launch the interactive REPL:

              $ storm
              bs> "Testing: " + 1.toS
              => Testing: 1

       To write programs, create a file, myprogram.bs for example, and write code there.  It  can
       then be loaded as follows:

              $ storm myprogram.bs
              bs> use myprogram
              using myprogram
              bs> main()
              ...

       As  the  above  example  attempts illustrate, this loads the contents of the file into the
       package myprogram. That package may then be imported and functions may  be  executed  from
       there. To execute the functions automatically, one can invoke storm as follows:

              $ storm myprogram.bs -f myprogram.main

       For  larger  programs, it is useful to put all files inside a directory and point storm to
       the directory rather than an individual file. In that case, the entire directory  will  be
       loaded as a package.

       If  the -i flag is not used to specify imports (as above), Storm will automatically try to
       execute the main function in the imported package(s). As such, the above  example  can  be
       simplified further as follows:

              $ storm myprogram.bs

OPTIONS

       storm recognizes the following command-line options.

       -l language
              Launch the interactive REPL for language. The default is to launch the bs REPL.

       -f function
              Execute function. The function may not require any formal parameters.

       -c expr
              Evaluate expr in the specified REPL.

       -t package
              Execute all tests in package.

       -T package
              Execute all tests in package and any sub-packages.

       -i path
              Import the directory or file path as a package in the root namespace.

       -I name path
              Import the directory path as a package with the name name.

       -r path
              Use  the  directory  path  as  the  root  of  the  namespace  in  Storm. By default
              /usr/lib/storm is used.

       --version
              Print version information.

       --server
              Launch the language server. Communicates with an editor using stdin/stdout using  a
              binary protocol.

       --help Print a summary of command-line options.

SEE ALSO

       For further information about Storm, see: ⟨https://storm-lang.org/⟩

                                           June 24 2021                                  STORM(1)