NAME

       scala - Run code in the Scala 2 language

SYNOPSIS

       scala  [ <option> ]... [ <torun> <argument>... ]

PARAMETERS

       <compiler-option>
              Any scalac option.  See scalac(1).

       -howtorun:<how>
              How  to execute <torun>, if it is present. Options for <how> are guess (the default), script, jar,
              and object.

       -i <file>
              Requests that a file be pre-loaded.  It is only meaningful for interactive shells.

       -e <string>
              Requests that its argument be executed as Scala code.

       -savecompiled
              Save this compiled version of scripts in order to speed up later executions of  the  same  script.
              When  running  a  script, save the compiled version in a file with the same name as the script but
              with an extension of .jar.  On subsequent runs of the same script, the pre-compiled .jar file will
              be used if it is newer than the script file.

       -nocompdaemon
              Do not use the fsc offline compiler.

       -nc    Same as -nocompdaemon.

       -Dproperty=value
              Set  a  Java  system  property.   If  no value is specified, then the property is set to the empty
              string.

       <torun>
              A top-level object or a script file to run.

       <argument>
              An arguments to pass to <torun>.

DESCRIPTION

       The scala utility runs Scala code using a Java runtime environment.  The Scala code to run  is  specified
       in one of three ways:

          1.  With no arguments specified, a Scala shell starts and reads commands interactively.

          2.  With  -howtorun:object  specified,  the  fully  qualified  name of a top-level Scala object may be
              specified.  The object should previously have been compiled using scalac(1).

          3.  With -howtorun:script specified, a file containing Scala code may be specified.

       If -howtorun: is left as the default (guess), then the scala command will check whether  a  file  of  the
       specified  name exists.  If it does, then it will treat it as a script file; if it does not, then it will
       treat it as the name of an object.

       In all three cases, arbitrary scalac options may be specified. The most common option  is  to  specify  a
       classpath with -classpath, but see the scalac(1) page for full details.

       If  an  object  is specified to run, then that object must be a top-level Scala object with the specified
       name.  The object must define a method main with the following signature:

       def main(args: Array[String]): Unit

       The method must return a Unit value, and it must accept a String array as  a  parameter.   All  arguments
       specified on the command line will be passed as arguments to the main method.

       If  a script file is specified to run, then the file is read and all Scala statements and declarations in
       the file are processed in order. Any arguments specified will be available via the argsvariable.

       Script files may have an optional header that is ignored if present.  There are two ways  to  format  the
       header: either beginning with #! and ending with !#, or beginning with ::#! and ending with ::!#.

       Such  a  header  must have each header boundary start at the beginning of a line.  Headers can be used to
       make stand-alone script files, as shown in the examples below.

       When running a script or using -e, an already running compilation daemon (fsc) is  used,  or  a  new  one
       started on demand.  The -nocompdaemon or -nc option can be used to prevent this.

       If  scala  is  run from an sbaz(1) directory, then it will add to its classpath any jars installed in the
       lib directory of the sbaz directory.  Additionally, if no -classpath option is specified, then scala will
       add ".", the current directory, to the end of the classpath.

OPTIONS

       If  any  compiler options are specified, they must be first in the command line and must be followed by a
       bare hypen ("-") character. If no arguments are specified after the optional compiler arguments, then  an
       interactive  Scala  shell  is  started.   Otherwise, either a script file is run, or a pre-compiled Scala
       object is run.  It is possible to distinguish the last two cases by using an explicit -object or  -script
       flag, but usually the program can guess correctly.

ENVIRONMENT

       JAVACMD
              Specify  the  java  command  to be used for running the Scala code.  Arguments may be specified as
              part of the environment variable; spaces, quotation marks, etc., will be passed  directly  to  the
              shell for expansion.

       JAVA_HOME
              Specify  JDK/JRE  home directory. This directory is used to locate the java command unless JAVACMD
              variable set.

       JAVA_OPTS
              Specify the options to be passed to the java command defined by JAVACMD.

              With Java 1.5 (or newer) one may for example configure the memory usage of  the  JVM  as  follows:
              JAVA_OPTS="-Xmx512M -Xms16M -Xss16M"

EXAMPLES

       Here are some examples of running Scala code:

       Execute a Scala program generated in the current directory
              scala hello.HelloWorld

       Execute a Scala program generated in a user-defined directory classes
              scala -classpath classes hello.HelloWorld

       Execute a Scala program using a user-defined java command
              env JAVACMD=/usr/local/bin/cacao scala -classpath classes hello.HelloWorld

       Execute a Scala program using JVM options
              env    JAVACMD=java    JAVA_OPTS="-Dmsg=hello    -enableassertions"   scala   -classpath   classes
              hello.HelloWorld

       Here is a complete Scala script for Unix:

       #!/bin/sh
       exec scala "$0" "$@"
       !#
       Console.println("Hello, world!")
       args.toList foreach Console.println

       Here is a complete Scala script for MS Windows:

       ::#!
       @echo off
       call scala %0 %*
       goto :eof
       ::!#
       Console.println("Hello, world!")
       args.toList foreach Console.println

       If you want to use the compilation cache to  speed  up  multiple  executions  of  the  script,  then  add
       -savecompiled to the scala command:

       #!/bin/sh
       exec scala -savecompiled "$0" "$@"
       !#
       Console.println("Hello, world!")
       args.toList foreach Console.println

EXIT STATUS

       The  scala  command returns a zero exit status if it succeeds. Non zero is returned in case of any error.
       If a script or top-level object is executed and returns a value, then that return value is passed  on  to
       scala.

AUTHOR

       Written by Martin Odersky and other members of the Scala team.

REPORTING BUGS

       Report bugs to https://issues.scala-lang.org/.

COPYRIGHT

       This  is open-source software, available to you under a BSD-like license. See accompanying "copyright" or
       "LICENSE" file for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS  FOR
       A PARTICULAR PURPOSE.

SEE ALSO

       fsc(1), scalac(1), scaladoc(1), scalap(1)