Capabilities

Every custom operation on the four builders, every Input combinator, and the Cmd argument helpers — one line each. Use it to find the name; the API reference has the full signature and remarks for each, and Composing reusable blocks has worked examples.

How settings resolve

A stage setting is answered by walking upward: the stage itself, then its parent stage, then the parent's parent, then the pipeline. The first level that set the thing wins, so workingDir on a pipeline covers every stage under it and a nested stage overrides it for itself and its own children. This applies to workingDir, envVars, the timeouts, acceptExitCodes, the output sink, noPrefixForStep, noStdRedirectForStep and verbosity.

Conditions are the exception. when', whenEnvVar, whenBranch and the platform operations conjoin: a second condition on the same stage narrows it to the logical AND of both. Use whenAny { } to widen.

A command's copies of the pipeline settings are defaults, not overrides: they reach every pipeline the command runs, but only where that pipeline left the setting alone, whichever order the two were written in. noPrefixForStep and noStdRedirectForStep are plain bools with no unset state: a pipeline setting either one to the same value PipelineContext.create already gives it reads back identically to a pipeline that never touched it, so the command default overwrites it in that case too.

Timeouts

Three names, and their meaning shifts with the builder they sit on.

All three accept int<second>, float seconds, or a TimeSpan, except on command, which takes int seconds or a TimeSpan.

Stage operations

Available inside stage, and inside whenStage, which accepts everything stage does.

A stage nested inside another stage is one step of its parent. Stages nest to any depth, and a block is just a value that a stage, a pipeline or a command can yield.

Pipeline operations

Available inside pipeline "name" { } and inside Command.pipeline { }, which takes the name and description of the command that runs it.

Command operations

Available inside command "name" { } and rootCommand argv { } / rootCommandOfScript { }, except for the three marked as root-only.

A command yields stages directly — command "test" { Stages.restore; Stages.test } — and consecutive stages become one implicit pipeline carrying the command's name and description. Command.pipeline { } is the same pipeline written out, for when it needs the pipeline-level settings; pipeline "name" { } is for when several pipelines run under one command, or when one needs a name of its own.

Condition builders

whenAll { }, whenAny { } and whenNot { } take these; each yields a single condition to a stage. An empty whenAll/whenNot is always active, an empty whenAny never is.

whenEnv { } describes one environment variable in place of a wall of overloads, with name, description, value, acceptValues and optional. whenStage "name" { } runs a stage for its result — everything stage accepts is accepted there, and the stage runs for real, side effects included.

whenSome value build and whenOk value build are functions rather than operations. Each returns a StageContext list: the stage built from the bound value, or []. The absent case is an empty list, not an inactive stage requiring a name. build receives the value already unwrapped, inside the condition that guards it.

Input combinators

Declaring functions:

Shaping combinators, all ActionInput<'T> -> ActionInput<'T> and all pipeable:

InputSpec<'T>

InputSpec<'T> is public at Partas.Build. A stage factory parameterised by an option needs no open Partas.Build.Internal:

let build (projects: InputSpec<string list>) = input {
    let! projects = projects
    and! config = Options.config
    ...
}

The input { let! … and! … return … } CE is the usual way to build one. It is applicative: bind every source in a single let!/and! group. A sequential second let! is a compile error (FS0708) because the input set has to be readable before anything is parsed. An input { } nested inside another's return produces an InputSpec<InputSpec<_>>, which nothing accepts — pass the source in as an InputSpec instead.

Cmd

A Cmd keeps the executable and its arguments apart all the way to ProcessStartInfo.ArgumentList, so the platform does the escaping.

Args

The arguments a script was given, as distinct from the ones its host was given.

dotnet fsi build.fsx -- test --quick does not reach the process with its -- intact: the dotnet driver consumes one before fsi sees the command line. Args.script locates the script's own filename instead of splitting on a separator.

Baked

Ready-made declarations for the options every build CLI ends up wanting. Baked.Input.* are options, Baked.Argument.* the positional equivalents.

Reference

• Overview — the layers, and a first pipeline.
• Composing reusable blocks — blocks, nesting, and composition across files.
• Stage CE run overloads.
• API reference — full signatures and remarks.