"rules": {
        "max-line-length": {
            "options": [160]
        },
        "arrow-parens": false,
        "new-parens": true,
        "no-arg": true,
        "no-bitwise": true,
        "no-conditional-assignment": true,
        "no-consecutive-blank-lines": true,
        "no-console": {
            "severity": "warning",
            "options": ["debug", "info", "log", "time", "timeEnd", "trace"]
        },

.Specifying when signing is required
====
include::sample[dir="snippets/signing/conditional/kotlin",files="build.gradle.kts[tags=conditional-signing]"]
include::sample[dir="snippets/signing/conditional/groovy",files="build.gradle[tags=conditional-signing]"]
====

In this example, we only want to require signing if we are building a release version and we are going to publish it.

rootProject.name = "customizing-resolution-conditional-substitution-rule"
val projectNames = listOf("project1", "project2", "project3")
include("consumer")

projectNames.forEach { name ->
    if (isIncluded(name)) {
        println("project $name is INTERNAL to this build")
        include(name)
    } else {
        println("project $name is external to this build")
    }
}

fun isIncluded(projectName: String): Boolean {

			_, _ = s, s
		}
	}()
}

var One float64 = 1.0

func f(d uintptr) {
	var a, m []int
	var s struct {
		a, b, c, d, e int
	}

	g(d, a, m, s, uint(One)) // Uint of not-a-constant inserts a conditional, necessary to bug

	defer func() uint {
		return 0
	}()
}

var d uintptr

func h() {
	f(d)

====
include::sample[dir="snippets/maven-publish/conditional-publishing/kotlin",files="build.gradle.kts[tags=task-config]"]
include::sample[dir="snippets/maven-publish/conditional-publishing/groovy",files="build.gradle[tags=task-config]"]
====

.Output of `gradle publish`
----
> gradle publish
include::{snippetsPath}/maven-publish/conditional-publishing/tests/publishingMavenConditionally.out[]
----

   * In a response, this field's name "no-cache" is misleading. It doesn't prevent us from caching
   * the response; it only means we have to validate the response with the origin server before
   * returning it. We can do this with a conditional GET.
   *
   * In a request, it means do not use a cache to satisfy the request.
   */
  @get:JvmName("noCache") val noCache: Boolean,
  /** If true, this response should not be cached. */

		}
	}
}

func canCondSelect(v *Value, arch string, loadAddr *sparseSet) bool {
	if loadAddr.contains(v.ID) {
		// The result of the soon-to-be conditional move is used to compute a load address.
		// We want to avoid generating a conditional move in this case
		// because the load address would now be data-dependent on the condition.
		// Previously it would only be control-dependent on the condition, which is faster

      advanced/nosql-databases.md: how-to/nosql-databases-couchbase.md
      advanced/graphql.md: how-to/graphql.md
      advanced/custom-request-and-route.md: how-to/custom-request-and-route.md
      advanced/conditional-openapi.md: how-to/conditional-openapi.md
      advanced/extending-openapi.md: how-to/extending-openapi.md
  mkdocstrings:
    handlers:
      python:
        options:
          extensions:
          - griffe_typingdoc

        3,
        CharStreams.readLines(r, alwaysTrue).intValue());

    // Test a LineProcessor that is conditional.
    r = new StringReader(text);
    final StringBuilder sb = new StringBuilder();
    LineProcessor<Integer> conditional =
        new LineProcessor<Integer>() {
          int seen;

          @Override
          public boolean processLine(String line) {

        3,
        CharStreams.readLines(r, alwaysTrue).intValue());

    // Test a LineProcessor that is conditional.
    r = new StringReader(text);
    final StringBuilder sb = new StringBuilder();
    LineProcessor<Integer> conditional =
        new LineProcessor<Integer>() {
          int seen;

          @Override
          public boolean processLine(String line) {