object Task extends TaskBase

Source
Task.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Task
  2. TaskBase
  3. TraverseCtxHolder
  4. Applyer
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. class ApplyFactory extends TraverseCtxHolder
  2. class CommandFactory extends TraverseCtxHolder
  3. abstract class Ops[+T] extends AnyRef

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. macro def Anon[T](t: Result[T]): Task[T]

    Creates an anonymous Task.

    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 T{...} targets.

  5. def Command(t: NamedParameterOnlyDummy = new NamedParameterOnlyDummy, exclusive: Boolean = false): CommandFactory

    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.

  6. macro def Command[T](t: Result[T])(implicit w: upickle.default.Writer[T], ctx: Ctx, cls: EnclosingClass): Command[T]

    Commands are only NamedTasks defined using def foo() = Task.Command{...} and are typically called from the command-line.

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

  7. macro def Input[T](value: Result[T])(implicit w: upickle.default.Writer[T], ctx: Ctx): Target[T]

    InputImpls, normally defined using Task.Input, are NamedTasks that re-evaluate every time Mill is run.

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

    InputImpls 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 T{...} TargetImpl 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 TargetImpls

    The most common case of InputImpl is SourceImpl and SourcesImpl, used for detecting changes to source files.

  8. macro def Source(value: Result[api.PathRef])(implicit ctx: Ctx): Target[api.PathRef]
  9. macro def Source(value: Result[Path])(implicit ctx: Ctx): Target[api.PathRef]

    Similar to Source, but only for a single source file or folder.

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

  10. macro def Sources(values: Result[Seq[api.PathRef]])(implicit ctx: Ctx): Target[Seq[api.PathRef]]
  11. macro def Sources(values: Result[Path]*)(implicit ctx: Ctx): Target[Seq[api.PathRef]]

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

    A specialization of InputImpl defined via Task.Sources, SourcesImpl 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 TargetImpls need to be invalidated and re-computed.

  12. macro def Worker[T](t: Result[T])(implicit ctx: Ctx): Worker[T]

    Worker is a NamedTask that lives entirely in-memory, defined using Task.Worker{...}.

    Worker is a NamedTask 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 MillServerMain 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.

  13. def apply(t: NamedParameterOnlyDummy = new NamedParameterOnlyDummy, persistent: Boolean = false): ApplyFactory

    Persistent tasks are defined using the Task(persistent = true){...} syntax.

    Persistent tasks are defined using the Task(persistent = true){...} syntax. The main difference is that while TargetImpl deletes the T.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 T.dest. Violating that invariant can result in confusing mis-behaviors

  14. macro def apply[T](t: Result[T])(implicit rw: upickle.default.ReadWriter[T], ctx: Ctx): Target[T]
  15. macro def apply[T](t: T)(implicit rw: upickle.default.ReadWriter[T], ctx: Ctx): Target[T]
  16. def args(implicit ctx: api.Ctx.Args): IndexedSeq[_]

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

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

    Definition Classes
    TaskBase
  17. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  18. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
  19. def ctx()(implicit c: api.Ctx): api.Ctx
    Definition Classes
    Applyer
  20. def dest(implicit ctx: Dest): Path

    T.dest is a unique os.Path (e.g.

    T.dest is a unique os.Path (e.g. out/classFiles.dest/ or out/run.dest/) that is assigned to every Target 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 Target or Command, so you can be sure that you will not collide or interfere with anyone else writing to those same paths.

    Definition Classes
    TaskBase
  21. def env(implicit ctx: Env): Map[String, String]

    T.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.

    T.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.

    Definition Classes
    TaskBase
  22. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  24. def fork(implicit ctx: api.Ctx): 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

    Definition Classes
    TaskBase
  25. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  26. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  27. def home(implicit ctx: Home): Path

    Returns the implicit mill.api.Ctx.Home.home in scope.

    Returns the implicit mill.api.Ctx.Home.home in scope.

    Definition Classes
    TaskBase
  28. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  29. def log(implicit ctx: Log): Logger

    T.log is the default logger provided for every task.

    T.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.

    Definition Classes
    TaskBase
  30. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  31. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  32. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  33. def reporter(implicit ctx: api.Ctx): (Int) => Option[CompileProblemReporter]

    Report build results to BSP for IDE integration

    Report build results to BSP for IDE integration

    Definition Classes
    TaskBase
  34. 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]]

    Definition Classes
    TaskBase
  35. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  36. def testReporter(implicit ctx: api.Ctx): TestReporter

    Report test results to BSP for IDE integration

    Report test results to BSP for IDE integration

    Definition Classes
    TaskBase
  37. def toString(): String
    Definition Classes
    AnyRef → Any
  38. 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]

    Definition Classes
    TaskBase
  39. def traverseCtx[I, R](xs: Seq[Task[I]])(f: (IndexedSeq[I], api.Ctx) => Result[R]): Task[R]

    A variant of traverse that also provides the mill.api.Ctx to the function f

    A variant of traverse that also provides the mill.api.Ctx to the function f

    Definition Classes
    TraverseCtxHolder
  40. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  41. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  42. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  43. def workspace(implicit ctx: api.Ctx): Path

    This is the os.Path pointing to the project root directory.

    This is the os.Path pointing to the project root directory.

    This is the preferred access to the project directory, and should always be prefered over os.pwd* (which might also point to the project directory in classic cli scenarios, but might not in other use cases like BSP or LSP server usage).

    Definition Classes
    TaskBase

Deprecated Value Members

  1. macro def apply[T](t: Task[T])(implicit rw: upickle.default.ReadWriter[T], ctx: Ctx): Target[T]
    Annotations
    @deprecated
    Deprecated

    (Since version Mill after 0.12.0-RC1) Creating a target from a task is deprecated. You most likely forgot a parenthesis pair ()

  2. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

Inherited from TaskBase

Inherited from TraverseCtxHolder

Inherited from Applyer[Task, Task, Result, api.Ctx]

Inherited from AnyRef

Inherited from Any

Ungrouped