mill-core-api
API
Generated with
mill-core-api/mill.api/Task

Task

mill.api.Task
See theTask companion class
object Task

Attributes

Companion
class
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Task.type

Members list

Type members

Classlikes

class Anon[T](val inputs: Seq[Task[_]], evaluate0: (Seq[Any], TaskCtx) => Result[T], enclosing: Enclosing) extends Task[T]

Attributes

Supertypes
class Task[T]
trait TaskApi[T]
trait Applyable[Task, T]
class Ops[T]
class Object
trait Matchable
class Any
Show all
class ApplyFactory

Attributes

Supertypes
class Object
trait Matchable
class Any
class Command[+T](val inputs: Seq[Task[Any]], val evaluate0: (Seq[Any], TaskCtx) => Result[T], val ctx0: ModuleCtx, val writer: Writer[_], val isPrivate: Option[Boolean], val exclusive: Boolean, val persistent: Boolean) extends Named[T]

Attributes

Supertypes
trait Named[T]
trait NamedTaskApi[T]
class Task[T]
trait TaskApi[T]
trait Applyable[Task, T]
class Ops[T]
class Object
trait Matchable
class Any
Show all
class CommandFactory

Attributes

Supertypes
class Object
trait Matchable
class Any
class Computed[+T](val inputs: Seq[Task[Any]], val evaluate0: (Seq[Any], TaskCtx) => Result[T], val ctx0: ModuleCtx, val readWriter: ReadWriter[_], val isPrivate: Option[Boolean], val persistent: Boolean) extends Simple[T]

Attributes

Supertypes
trait Simple[T]
trait Named[T]
trait NamedTaskApi[T]
class Task[T]
trait TaskApi[T]
trait Applyable[Task, T]
class Ops[T]
class Object
trait Matchable
class Any
Show all
class Input[T](val evaluate0: (Seq[Any], TaskCtx) => Result[T], val ctx0: ModuleCtx, val writer: Writer[_], val isPrivate: Option[Boolean]) extends Simple[T]

Attributes

Supertypes
trait Simple[T]
trait Named[T]
trait NamedTaskApi[T]
class Task[T]
trait TaskApi[T]
trait Applyable[Task, T]
class Ops[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
class Source
class Sources
@Scaladoc(value = "/**\n * Represents a task that can be referenced by its path segments. `Task{...}`\n * tasks, `Task.Input`, `Task.Worker`, etc. but not including anonymous\n * `Task.Anon` or `Task.traverse` etc. instances\n */")
trait Named[+T] extends Task[T], NamedTaskApi[T]

Represents a task that can be referenced by its path segments. Task{...} tasks, Task.Input, Task.Worker, etc. but not including anonymous Task.Anon or Task.traverse etc. instances

Represents a task that can be referenced by its path segments. Task{...} tasks, Task.Input, Task.Worker, etc. but not including anonymous Task.Anon or Task.traverse etc. instances

Attributes

Supertypes
trait NamedTaskApi[T]
class Task[T]
trait TaskApi[T]
trait Applyable[Task, T]
class Ops[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
class Command[T]
trait Simple[T]
class Computed[T]
class Input[T]
class Source
class Sources
class Worker[T]
Show all
abstract class Ops[+T]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Task[T]
class Anon[T]
trait Named[T]
class Command[T]
trait Simple[T]
class Computed[T]
class Input[T]
class Source
class Sources
class Worker[T]
Show all
Self type
Task[T]
object Simple

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Simple.type
@Scaladoc(value = "/**\n * A Simple Task is a [[Task.Named]] that is cached on disk; either a\n * [[Task.Computed]] or an [[Input]]\n */")
trait Simple[+T] extends Named[T]

A Simple Task is a Task.Named that is cached on disk; either a Task.Computed or an Input

A Simple Task is a Task.Named that is cached on disk; either a Task.Computed or an Input

Attributes

Companion
object
Supertypes
trait Named[T]
trait NamedTaskApi[T]
class Task[T]
trait TaskApi[T]
trait Applyable[Task, T]
class Ops[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
class Computed[T]
class Input[T]
class Source
class Sources
class Source(evaluate0: (Seq[Any], TaskCtx) => Result[PathRef], ctx0: ModuleCtx, isPrivate: Option[Boolean]) extends Input[PathRef]

Attributes

Supertypes
class Input[PathRef]
trait Simple[PathRef]
trait Named[PathRef]
trait NamedTaskApi[PathRef]
class Task[PathRef]
trait TaskApi[PathRef]
class Ops[PathRef]
class Object
trait Matchable
class Any
Show all
class Sources(evaluate0: (Seq[Any], TaskCtx) => Result[Seq[PathRef]], ctx0: ModuleCtx, isPrivate: Option[Boolean]) extends Input[Seq[PathRef]]

Attributes

Supertypes
class Input[Seq[PathRef]]
trait Simple[Seq[PathRef]]
trait Named[Seq[PathRef]]
trait NamedTaskApi[Seq[PathRef]]
class Task[Seq[PathRef]]
trait TaskApi[Seq[PathRef]]
trait Applyable[Task, Seq[PathRef]]
class Ops[Seq[PathRef]]
class Object
trait Matchable
class Any
Show all
class Worker[+T](val inputs: Seq[Task[Any]], val evaluate0: (Seq[Any], TaskCtx) => Result[T], val ctx0: ModuleCtx, val isPrivate: Option[Boolean]) extends Named[T]

Attributes

Supertypes
trait Named[T]
trait NamedTaskApi[T]
class Task[T]
trait TaskApi[T]
trait Applyable[Task, T]
class Ops[T]
class Object
trait Matchable
class Any
Show all

Value members

Concrete methods

@Scaladoc(value = "/**\n * Creates an anonymous `Task`. These depend on other tasks and\n * be-depended-upon by other tasks, but cannot be run directly from the\n * command line and do not perform any caching. Typically used as helpers to\n * implement `Task{...}` tasks.\n */")
inline def Anon[T](inline t: Result[T])(implicit inline enclosing: Enclosing): Task[T]

Creates an anonymous Task. These depend on other tasks and be-depended-upon by other tasks, but cannot be run directly from the command line and do not perform any caching. Typically used as helpers to implement Task{...} tasks.

Creates an anonymous Task. These depend on other tasks and be-depended-upon by other tasks, but cannot be run directly from the command line and do not perform any caching. Typically used as helpers to implement Task{...} tasks.

Attributes

@Scaladoc(value = "/**\n * [[Command]]s are only [[Task.Named]]s defined using\n * `def foo() = Task.Command{...}` and are typically called from the\n * command-line. Unlike other [[Task.Named]]s, [[Command]]s can be defined to\n * take arguments that are automatically converted to command-line\n * arguments, as long as an implicit [[mainargs.TokensReader]] is available.\n */")
inline def Command[T](inline t: Result[T])(implicit inline w: Writer[T], inline ctx: ModuleCtx): Command[T]

Commands are only Task.Nameds defined using def foo() = Task.Command{...} and are typically called from the command-line. Unlike other Task.Nameds, Commands can be defined to take arguments that are automatically converted to command-line arguments, as long as an implicit mainargs.TokensReader is available.

Commands are only Task.Nameds defined using def foo() = Task.Command{...} and are typically called from the command-line. Unlike other Task.Nameds, Commands can be defined to take arguments that are automatically converted to command-line arguments, as long as an implicit mainargs.TokensReader is available.

Attributes

@Scaladoc(value = "/**\n * @param exclusive Exclusive commands run serially at the end of an evaluation,\n * without any other tasks running parallel, and without the\n * terminal logging prefixes that are applied to normal tasks.\n * These are normally used for \"top level\" commands which are\n * run directly to perform some action or display some output\n * to the user.\n * @param persistent If true the `Task.dest` directory is not cleaned between\n * runs.\n */")
def Command(t: NamedParameterOnlyDummy, exclusive: Boolean, persistent: Boolean): CommandFactory

Value parameters

exclusive

Exclusive commands run serially at the end of an evaluation, without any other tasks running parallel, and without the terminal logging prefixes that are applied to normal tasks. These are normally used for "top level" commands which are run directly to perform some action or display some output to the user.

persistent

If true the Task.dest directory is not cleaned between runs.

Attributes

@Scaladoc(value = "/**\n * [[Input]]s, normally defined using `Task.Input`, are [[Task.Named]]s that\n * re-evaluate every time Mill is run. This is in contrast to [[Task.Computed]]s\n * which only re-evaluate when upstream tasks change.\n *\n * [[Input]]s are useful when you want to capture some input to the Mill\n * build graph that comes from outside: maybe from an environment variable, a\n * JVM system property, the hash returned by `git rev-parse HEAD`. Reading\n * these external mutable variables inside a `Task{...}` [[Task.Computed]] will\n * incorrectly cache them forever. Reading them inside a `Task.Input{...}`\n * will re-compute them every time, and only if the value changes would it\n * continue to invalidate downstream [[Task.Computed]]s\n *\n * The most common case of [[Input]] is [[Source]] and [[Sources]],\n * used for detecting changes to source files.\n */")
inline def Input[T](inline value: Result[T])(implicit inline w: Writer[T], inline ctx: ModuleCtx): Simple[T]

Inputs, normally defined using Task.Input, are Task.Nameds that re-evaluate every time Mill is run. This is in contrast to Task.Computeds which only re-evaluate when upstream tasks change.

Inputs, normally defined using Task.Input, are Task.Nameds that re-evaluate every time Mill is run. This is in contrast to Task.Computeds which only re-evaluate when upstream tasks change.

Inputs are useful when you want to capture some input to the Mill build graph that comes from outside: maybe from an environment variable, a JVM system property, the hash returned by git rev-parse HEAD. Reading these external mutable variables inside a Task{...} Task.Computed will incorrectly cache them forever. Reading them inside a Task.Input{...} will re-compute them every time, and only if the value changes would it continue to invalidate downstream Task.Computeds

The most common case of Input is Source and Sources, used for detecting changes to source files.

Attributes

@Scaladoc(value = "/**\n * Similar to [[Sources]], but only for a single source file or folder. Defined\n * using `Task.Source`.\n */")
inline def Source(inline value: SubPath | FilePath)(implicit inline ctx: ModuleCtx): Simple[PathRef]

Similar to Sources, but only for a single source file or folder. Defined using Task.Source.

Similar to Sources, but only for a single source file or folder. Defined using Task.Source.

Attributes

@Scaladoc(value = "/**\n * A specialization of [[Input]] defined via `Task.Sources`, [[Sources]]\n * uses [[PathRef]]s to compute a signature for a set of source files and\n * folders.\n *\n * This is most used when detecting changes in source code: when you edit a\n * file and run `mill compile`, it is the `Task.Sources` that re-computes the\n * signature for you source files/folders and decides whether or not downstream\n * [[Task.Computed]]s need to be invalidated and re-computed.\n */")
inline def Sources(inline values: SubPath | FilePath*)(implicit inline ctx: ModuleCtx): Simple[Seq[PathRef]]

A specialization of Input defined via Task.Sources, Sources uses PathRefs to compute a signature for a set of source files and folders.

A specialization of Input defined via Task.Sources, Sources uses PathRefs to compute a signature for a set of source files and folders.

This is most used when detecting changes in source code: when you edit a file and run mill compile, it is the Task.Sources that re-computes the signature for you source files/folders and decides whether or not downstream Task.Computeds need to be invalidated and re-computed.

Attributes

@Scaladoc(value = "/**\n * [[Worker]] is a [[Task.Named]] that lives entirely in-memory, defined using\n * `Task.Worker{...}`. The value returned by `Task.Worker{...}` is long-lived,\n * persisting as long as the Mill process is kept alive (e.g. via `--watch`,\n * or via its default `MillDaemonMain` server process). This allows the user to\n * perform in-memory caching that is even more aggressive than the disk-based\n * caching enabled by [[PersistentImpl]]: your [[Worker]] can cache running\n * sub-processes, JVM Classloaders with JITed code, and all sorts of things\n * that do not easily serialize to JSON on disk.\n *\n * Like [[PersistentImpl]], The user defining a [[Worker]] assumes the\n * responsibility of ensuring the implementation is idempotent regardless of\n * what in-memory state the worker may have.\n */")
inline def Worker[T](inline t: Result[T])(implicit inline ctx: ModuleCtx): Worker[T]

Worker is a Task.Named that lives entirely in-memory, defined using Task.Worker{...}. The value returned by Task.Worker{...} is long-lived, persisting as long as the Mill process is kept alive (e.g. via --watch, or via its default MillDaemonMain server process). This allows the user to perform in-memory caching that is even more aggressive than the disk-based caching enabled by PersistentImpl: your Worker can cache running sub-processes, JVM Classloaders with JITed code, and all sorts of things that do not easily serialize to JSON on disk.

Worker is a Task.Named that lives entirely in-memory, defined using Task.Worker{...}. The value returned by Task.Worker{...} is long-lived, persisting as long as the Mill process is kept alive (e.g. via --watch, or via its default MillDaemonMain server process). This allows the user to perform in-memory caching that is even more aggressive than the disk-based caching enabled by PersistentImpl: your Worker can cache running sub-processes, JVM Classloaders with JITed code, and all sorts of things that do not easily serialize to JSON on disk.

Like PersistentImpl, The user defining a Worker assumes the responsibility of ensuring the implementation is idempotent regardless of what in-memory state the worker may have.

Attributes

inline def apply[T](inline t: Result[T])(implicit inline rw: ReadWriter[T], inline ctx: ModuleCtx): Simple[T]
@Scaladoc(value = "/**\n * Persistent tasks are defined using\n * the `Task(persistent = true){...}` syntax. The main difference is that while\n * [[Task.Computed]] deletes the `Task.dest` folder in between runs,\n * [[PersistentImpl]] preserves it. This lets the user make use of files on\n * disk that persistent between runs of the task, e.g. to implement their own\n * fine-grained caching beyond what Mill provides by default.\n *\n * Note that the user defining a `Task(persistent = true)` task is taking on the\n * responsibility of ensuring that their implementation is idempotent, i.e.\n * that it computes the same result whether or not there is data in `Task.dest`.\n * Violating that invariant can result in confusing mis-behaviors\n */")
def apply(t: NamedParameterOnlyDummy, persistent: Boolean): ApplyFactory

Persistent tasks are defined using the Task(persistent = true){...} syntax. The main difference is that while Task.Computed deletes the Task.dest folder in between runs, PersistentImpl preserves it. This lets the user make use of files on disk that persistent between runs of the task, e.g. to implement their own fine-grained caching beyond what Mill provides by default.

Persistent tasks are defined using the Task(persistent = true){...} syntax. The main difference is that while Task.Computed deletes the Task.dest folder in between runs, PersistentImpl preserves it. This lets the user make use of files on disk that persistent between runs of the task, e.g. to implement their own fine-grained caching beyond what Mill provides by default.

Note that the user defining a Task(persistent = true) task is taking on the responsibility of ensuring that their implementation is idempotent, i.e. that it computes the same result whether or not there is data in Task.dest. Violating that invariant can result in confusing mis-behaviors

Attributes

@Scaladoc(value = "/**\n * Returns the implicit [[mill.api.TaskCtx.Args.args]] in scope.\n */")
def args(implicit ctx: Args): IndexedSeq[_]

Returns the implicit mill.api.TaskCtx.Args.args in scope.

Returns the implicit mill.api.TaskCtx.Args.args in scope.

Attributes

@Scaladoc(value = "/**\n * Returns the [[mill.api.TaskCtx]] that is available within this task\n */")
def ctx()(implicit c: TaskCtx): TaskCtx

Returns the mill.api.TaskCtx that is available within this task

Returns the mill.api.TaskCtx that is available within this task

Attributes

@Scaladoc(value = "/**\n * `Task.dest` is a unique `os.Path` (e.g. `out/classFiles.dest/` or `out/run.dest/`)\n * that is assigned to every Task or Command. It is cleared before your\n * task runs, and you can use it as a scratch space for temporary files or\n * a place to put returned artifacts. This is guaranteed to be unique for\n * every Task or Command, so you can be sure that you will not collide or\n * interfere with anyone else writing to those same paths.\n */")
def dest(implicit ctx: Dest): Path

Task.dest is a unique os.Path (e.g. out/classFiles.dest/ or out/run.dest/) that is assigned to every Task or Command. It is cleared before your task runs, and you can use it as a scratch space for temporary files or a place to put returned artifacts. This is guaranteed to be unique for every Task or Command, so you can be sure that you will not collide or interfere with anyone else writing to those same paths.

Task.dest is a unique os.Path (e.g. out/classFiles.dest/ or out/run.dest/) that is assigned to every Task or Command. It is cleared before your task runs, and you can use it as a scratch space for temporary files or a place to put returned artifacts. This is guaranteed to be unique for every Task or Command, so you can be sure that you will not collide or interfere with anyone else writing to those same paths.

Attributes

@Scaladoc(value = "/**\n * `Task.env` is the environment variable map passed to the Mill command when\n * it is run; typically used inside a `Task.Input` to ensure any changes in\n * the env vars are properly detected.\n *\n * Note that you should not use `sys.env`, as Mill\'s long-lived server\n * process means that `sys.env` variables may not be up to date.\n */")
def env(implicit ctx: Env): Map[String, String]

Task.env is the environment variable map passed to the Mill command when it is run; typically used inside a Task.Input to ensure any changes in the env vars are properly detected.

Task.env is the environment variable map passed to the Mill command when it is run; typically used inside a Task.Input to ensure any changes in the env vars are properly detected.

Note that you should not use sys.env, as Mill's long-lived server process means that sys.env variables may not be up to date.

Attributes

def fail(msg: String)(implicit ctx: TaskCtx): Nothing
@Scaladoc(value = "/**\n * Provides the `.fork.async` and `.fork.await` APIs for spawning and joining\n * async futures within your task in a Mill-friendly mannter\n */")
def fork(implicit ctx: TaskCtx): Api

Provides the .fork.async and .fork.await APIs for spawning and joining async futures within your task in a Mill-friendly mannter

Provides the .fork.async and .fork.await APIs for spawning and joining async futures within your task in a Mill-friendly mannter

Attributes

@Scaladoc(value = "/**\n * `Task.log` is the default logger provided for every task. While your task is running,\n * `System.out` and `System.in` are also redirected to this logger. The logs for a\n * task are streamed to standard out/error as you would expect, but each task\'s\n * specific output is also streamed to a log file on disk, e.g. `out/run.log` or\n * `out/classFiles.log` for you to inspect later.\n *\n * Messages logged with `log.debug` appear by default only in the log files.\n * You can use the `--debug` option when running mill to show them on the console too.\n */")
def log(implicit ctx: Log): Logger

Task.log is the default logger provided for every task. While your task is running, System.out and System.in are also redirected to this logger. The logs for a task are streamed to standard out/error as you would expect, but each task's specific output is also streamed to a log file on disk, e.g. out/run.log or out/classFiles.log for you to inspect later.

Task.log is the default logger provided for every task. While your task is running, System.out and System.in are also redirected to this logger. The logs for a task are streamed to standard out/error as you would expect, but each task's specific output is also streamed to a log file on disk, e.g. out/run.log or out/classFiles.log for you to inspect later.

Messages logged with log.debug appear by default only in the log files. You can use the --debug option when running mill to show them on the console too.

Attributes

def offline(implicit ctx: TaskCtx): Boolean
@Scaladoc(value = "/**\n * Report build results to BSP for IDE integration\n */")
def reporter(implicit ctx: TaskCtx): Int => Option[CompileProblemReporter]

Report build results to BSP for IDE integration

Report build results to BSP for IDE integration

Attributes

@Scaladoc(value = "/**\n * Converts a `Seq[Task[T]]` into a `Task[Seq[T]]`\n */")
def sequence[T](source: Seq[Task[T]]): Task[Seq[T]]

Converts a Seq[Task[T]] into a Task[Seq[T]]

Converts a Seq[Task[T]] into a Task[Seq[T]]

Attributes

@Scaladoc(value = "/**\n * Report test results to BSP for IDE integration\n */")
def testReporter(implicit ctx: TaskCtx): TestReporter

Report test results to BSP for IDE integration

Report test results to BSP for IDE integration

Attributes

@Scaladoc(value = "/**\n * Converts a `Seq[T]` into a `Task[Seq[V]]` using the given `f: T => Task[V]`\n */")
def traverse[T, V](source: Seq[T])(f: T => Task[V]): Task[Seq[V]]

Converts a Seq[T] into a Task[Seq[V]] using the given f: T => Task[V]

Converts a Seq[T] into a Task[Seq[V]] using the given f: T => Task[V]

Attributes

Generated with