public static <T extends Collection<?>> T flatten(Object[] elements, T addTo, boolean flattenMaps) {
        return flatten(asList(elements), addTo, flattenMaps);
    }

    public static <T extends Collection<?>> T flatten(Object[] elements, T addTo) {
        return flatten(asList(elements), addTo);
    }

    public static <T extends Collection<?>> T flatten(Collection<?> elements, T addTo) {

                DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.FLATTEN, project));
    }

    @Nonnull
    default DependencyResolverResult flatten(
            @Nonnull Session session, @Nonnull Project project, @Nonnull PathScope scope) {
        return flatten(DependencyResolverRequest.build(
                session, DependencyResolverRequest.RequestType.FLATTEN, project, scope));
    }

        flatten(s4) == [parent.path, "1:dir1", "2:dir2", "2:dir5/and/more", "1:dir6"]

        def s5 = s4.plus(dir1)
        flatten(s5) == [parent.path, "1:dir1", "1:dir6"]

        def s6 = s3.plus(dir1)
        flatten(s6) == [parent.path, "1:dir1", "1:dir6"]

        def s7 = s3.plus(parent)
        flatten(s7) == [parent.path]
    }

    def "has a nice toString representation"() {

        then:
        methods.methodNames() == (["doSomething"] as Set)
        methods.allMethods().values().flatten()*.name == ["doSomething", "doSomething"]
        methods.allMethods().values().flatten()*.declaringClass == [Child, Base]
        methods.allMethods().values()*.declaredAnnotations.flatten()*.annotationType() == [Nullable, Incubating]
    }

    @Managed
    abstract class ManagedType  {

        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a"), file("b")]
    }

    def "can register named output files"() {
        when:
        outputs.files("fileA": "a", "fileB": "b")
        then:
        outputs.files.files == files('a', "b")
        outputs.fileProperties*.propertyName == ['$1.fileA', '$1.fileB']
        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a"), file("b")]

        expect:
        def s1 = snapshot(dir1dir2dir3, dir1dir5)
        flatten(s1) == [dir1.path, "1:dir2/dir3", "1:dir5/and/more"]

        def s2 = updateDir(s1, dir1dir2dir4)
        flatten(s2) == [dir1.path, "1:dir2", "2:dir3", "2:dir4", "1:dir5/and/more"]

        def s3 = updateDir(s2, dir6)
        flatten(s3) == [parent.path, "1:dir1", "2:dir2", "3:dir3", "3:dir4", "2:dir5/and/more", "1:dir6"]

		path       string
		isNil      bool
		size, objs int
		flatten    bool
		oSizes     sizeHistogram
	}{
		{
			path:    "/",
			size:    363515,
			flatten: true,
			objs:    14,
			oSizes:  sizeHistogram{0: 7, 1: 5, 2: 2},
		},
		{
			path:    "/dir1",
			size:    342210,
			objs:    7,
			flatten: false,
			oSizes:  sizeHistogram{0: 2, 1: 3, 2: 2},
		},
		{

    public static <T extends Collection<?>> T flatten(Object[] elements, T addTo, boolean flattenMaps) {
        return flatten(asList(elements), addTo, flattenMaps);
    }

    public static <T extends Collection<?>> T flatten(Object[] elements, T addTo) {
        return flatten(asList(elements), addTo);
    }

    public static <T extends Collection<?>> T flatten(Collection<?> elements, T addTo) {

        1 -> providers.single()
        else -> composeProviders(providers)
    }

    public fun createFlattened(providers: List<P>): P =
        create(if (providers.size > 1) flatten(providers) else providers)

    public fun flatten(providers: List<P>): List<P> =
        providers.flatMap { provider ->
            // `KotlinCompositeProvider<P>` should always be a provider of type `P` itself, so the cast is legal. Still, suppressing the

        toWords("123Thing") == "123 thing"
        toWords(".") == ""
        toWords("_") == ""
    }

    def "flattens maps and arrays"() {
        expect:
        flatten([[1], [foo: 'bar']]) == [1, 'bar']

        Object[] array = [1]
        flatten([array, [foo: 'bar']]) == [1, 'bar']
    }

    def "flattening of maps controls flatting of arrays"() {