scala.annotation
Type members
Classlikes
MainAnnotation provides the functionality for a compiler-generated main class. It links a compiler-generated main method (call it compiler-main) to a user written main method (user-main). The protocol of calls from compiler-main is as follows:
MainAnnotation provides the functionality for a compiler-generated main class. It links a compiler-generated main method (call it compiler-main) to a user written main method (user-main). The protocol of calls from compiler-main is as follows:
- create a
command
with the command line arguments, - for each parameter of user-main, a call to
command.argGetter
, orcommand.varargGetter
if is a final varargs parameter, - a call to
command.run
with the closure of user-main applied to all arguments.
Example:
/** Sum all the numbers
*
* @param first Fist number to sum
* @param rest The rest of the numbers to sum
*/
@myMain def sum(first: Int, second: Int = 0, rest: Int*): Int = first + second + rest.sum
generates
object foo {
def main(args: Array[String]): Unit = {
val mainAnnot = new myMain()
val info = new Info(
name = "foo.main",
documentation = "Sum all the numbers",
parameters = Seq(
new Parameter("first", "scala.Int", hasDefault=false, isVarargs=false, "Fist number to sum"),
new Parameter("rest", "scala.Int" , hasDefault=false, isVarargs=true, "The rest of the numbers to sum")
)
)
val mainArgsOpt = mainAnnot.command(info, args)
if mainArgsOpt.isDefined then
val mainArgs = mainArgsOpt.get
val args0 = mainAnnot.argGetter[Int](info.parameters(0), mainArgs(0), None) // using parser Int
val args1 = mainAnnot.argGetter[Int](info.parameters(1), mainArgs(1), Some(() => sum$default$1())) // using parser Int
val args2 = mainAnnot.varargGetter[Int](info.parameters(2), mainArgs.drop(2)) // using parser Int
mainAnnot.run(() => sum(args0(), args1(), args2()*))
}
}
- Value parameters:
- Parser
The class used for argument string parsing and arguments into a
T
- Result
The required result type of the main method. If this type is Any or Unit, any type will be accepted.
- Companion:
- object
A base trait for annotations that yield proper subtypes of the types they annotate. Refining annotations are more "sticky" than normal ones. They are conceptually kept around when normal refinements would also not be stripped away.
A base trait for annotations that yield proper subtypes of the types they annotate. Refining annotations are more "sticky" than normal ones. They are conceptually kept around when normal refinements would also not be stripped away.
An annotation that goes on parameters of classes or traits. It asserts that the parameter is used only for initialization and is not kept in the class as a field. Violations of this assertion are flagged as compile errors. The annotation is particularly useful for implicit parameters since for these a textual scan is not sufficient to know where they are used.
An annotation that goes on parameters of classes or traits. It asserts that the parameter is used only for initialization and is not kept in the class as a field. Violations of this assertion are flagged as compile errors. The annotation is particularly useful for implicit parameters since for these a textual scan is not sufficient to know where they are used.
An annotation that can be used to mark a definition as experimental.
An annotation that can be used to mark a definition as experimental.
- See also:
https://github.com/scala/scala.github.com/pull/491
An annotation that defines an external name for a definition.
If an targetName(extname)
annotation is given for a method or some other
definition, its implementation will use the name extname
instead of
the regular name.
An annotation that defines an external name for a definition.
If an targetName(extname)
annotation is given for a method or some other
definition, its implementation will use the name extname
instead of
the regular name.
This annotation can only be used on a field which defines a lazy val. When this annotation is used, the initialization of the lazy val will use a faster mechanism which is not thread-safe.
This annotation can only be used on a field which defines a lazy val. When this annotation is used, the initialization of the lazy val will use a faster mechanism which is not thread-safe.
An annotation that can be used from Scala 2 to mark a trait as transparent.
Scala 3 code would use the modifier transparent
instead. Transparent traits
are not inferred when combined with other types in an intersection.
See reference/other-new-features/transparent-traits.html for details.
An annotation that can be used from Scala 2 to mark a trait as transparent.
Scala 3 code would use the modifier transparent
instead. Transparent traits
are not inferred when combined with other types in an intersection.
See reference/other-new-features/transparent-traits.html for details.
Deprecated classlikes
An annotation that defines an external name for a definition.
If an alpha(extname)
annotation is given for a method or some other
definition, its implementation will use the name extname
instead of
the regular name. An alpha
annotation is mandatory for definitions
with symbolic names.
An annotation that defines an external name for a definition.
If an alpha(extname)
annotation is given for a method or some other
definition, its implementation will use the name extname
instead of
the regular name. An alpha
annotation is mandatory for definitions
with symbolic names.
- Deprecated