NamedDomainObjectList<Person> people = project.container(Person)

    // Add a person to the container
    void addPerson(String name) {
        people.create(name: name)
    }
}
// end::ndol[]

// tag::ndoc[]

abstract class MyPluginExtensionNamedDomainObjectContainer {
    // Define a named domain object container to hold Person objects

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FoldConstantsToSubgraphPass)

  llvm::StringRef getArgument() const final {
    return "tfl-fold-constants-to-subgraph";
  }
  llvm::StringRef getDescription() const final {
    return "Fold constants into each subgraph.";
  }
  FoldConstantsToSubgraphPass() = default;
  FoldConstantsToSubgraphPass(const FoldConstantsToSubgraphPass& other) {

                path = pomPath.toAbsolutePath().toString();
            }
        }

        return path;
    }

    static String toId(Model model) {
        if (model == null) {
            return "";
        }
        return toId(model.getDelegate());
    }

    static String toId(org.apache.maven.api.model.Model model) {
        String groupId = model.getGroupId();
        if (groupId == null && model.getParent() != null) {

		// at the top.
		a.stackBytes = align(a.stackBytes, uintptr(t.Align()))
		return nil
	}
	// Hold a copy of "a" so that we can roll back if
	// register assignment fails.
	aOld := *a
	if !a.regAssign(t, 0) {
		// Register assignment failed. Roll back any changes
		// and stack-assign.
		*a = aOld
		a.stackAssign(t.Size(), uintptr(t.Align()))
		return &a.steps[len(a.steps)-1]
	}
	return nil
}

				"requests.storage",
				"persistentvolumeclaims",
				"gold.storageclass.storage.k8s.io/requests.storage",
				"gold.storageclass.storage.k8s.io/persistentvolumeclaims",
			},

			want: []corev1.ResourceName{
				"count/persistentvolumeclaims",
				"requests.storage",
				"persistentvolumeclaims",
				"gold.storageclass.storage.k8s.io/requests.storage",
				"gold.storageclass.storage.k8s.io/persistentvolumeclaims",
			},

  color: #02303A;
  content: '\002022';
  font: 0.9em bold sans-serif;
  margin-left: -1em;
  margin-right: 0.4em;
}

li.mainTopic :before {
  color: #02303A;
  content: '\002022';
  font: 0.9em bold sans-serif;
  margin-left: -1em;
  margin-right: 0.4em;
}

li.subTopic :before {
  color: #02303A;
  content: '\002022';
  font: 0.9em bold sans-serif;
  margin-left: 3em;
  margin-right: 0.4em;
}

    }

    def "fold() subsumes flatMap()"() {
        expect:
        left.fold({ assert it == LEFT; either(LEFT2) }, { assert false }).left.get() == LEFT2

        right.fold({ assert false }, { assert it == RIGHT; either(RIGHT2) }).right.get() == RIGHT2
    }

    def "fold() works"() {
        expect:
        left.fold({ assert it == LEFT; LEFT2 }, { assert false }) == LEFT2

import static org.gradle.internal.logging.text.StyledTextOutput.Style.UserInput;

public class DefaultColorMap implements ColorMap {
    private static final String STATUS_BAR = "statusbar";
    private static final String BOLD = "bold";
    private static final String COLOR_DIVIDER = "-";

    /**
     * Maps a {@link StyledTextOutput.Style} to the default color spec (that can be overridden by system properties)
     */

	fmt.Fprintln(banner, color.Bold("%s version %s (commit-id=%s)", c.App.Name, c.App.Version, CommitID))
	fmt.Fprintln(banner, color.Blue("Runtime:")+color.Bold(" %s %s/%s", runtime.Version(), runtime.GOOS, runtime.GOARCH))
	fmt.Fprintln(banner, color.Blue("License:")+color.Bold(" GNU AGPLv3 - https://www.gnu.org/licenses/agpl-3.0.html"))
	fmt.Fprintln(banner, color.Blue("Copyright:")+color.Bold(" 2015-%s MinIO, Inc.", CopyrightYear))

                                            TypeRangeWithDesc range0,
                                            TypeRangeWithDesc range1);

// Fold Arithmetic Op if one of the operands is a constant known to be an
// Identity (e.g. X+0, X*1, etc...). For commutative operations fold if
// known identity value is either lhs or rhs.
template <
    typename OpT,
    typename std::enable_if<llvm::is_one_of<