}

    /**
     * Recursively unpacks all the given things into a flat list.
     *
     * Nulls are not removed, they are left intact.
     *
     * @param things The things to flatten
     * @return A flattened list of the given things
     */
    public static List<?> flattenCollections(Object... things) {
        return flattenCollections(Object.class, things);
    }

    /**

        }

        fun assertHasErrors(vararg errors: List<String>) {
            assertHasErrors(*errors.toList().flatten().toTypedArray())
        }

        fun assertHasErrors(vararg errorWithDetail: Pair<String, List<String>>) {

        succeeds 'build'

        then:
        def progressOutputEvents = operations.all(Pattern.compile('.*'))
            .collect { it.progress }
            .flatten()
            .with { it as List<BuildOperationRecord.Progress> }
            .findAll { OutputEvent.isAssignableFrom(it.detailsType) }

        // 11 tasks + "\n" + "BUILD SUCCESSFUL" + "2 actionable tasks: 2 executed"

            visitNodes(this.root, result)
            return result.collect { it.artifacts }.flatten()
        }

        Set<String> getFiles() {
            Set<NodeBuilder> result = new LinkedHashSet()
            result.add(this.root)
            visitNodes(this.root, result)
            return result.collect { node -> node.files }.flatten()
        }

        private void visitNodes(NodeBuilder node, Set<NodeBuilder> result) {

     */
    @Nonnull
    Node collectDependencies(@Nonnull DependencyCoordinate dependency);

    /**
     * Shortcut for {@code getService(DependencyResolver.class).flatten(...)}.
     *
     * @param node node for which to get a flattened list
     * @param scope build path scope (main compile, test compile, etc.) of desired nodes

        when:
        succeeds 'resolve'

        then:
        def ops = operations.all(ResolveConfigurationDependenciesBuildOperationType)
        ops.size() == 3
        ops.details.repositories.flatten().unique(false).size() == 1
    }

    def "repositories shared across projects are stable"() {
        setup:
        createDirs("child")
        settingsFile << """
            include 'child'

    llvm::StringRef equation, RankedTensorType lhs_ty) {
  llvm::StringRef lhs;
  llvm::StringRef out;
  std::tie(lhs, out) = equation.split("->");
  if (lhs.empty() || out.empty()) return std::nullopt;

  // Try to flatten the "..." if possible.
  int lhs_named_label, rhs_named_label;

  // following rhs and rhs_ty variables are non-functional here only created to
  // comply with the existing API
  llvm::StringRef rhs;

        and:
        def buildFinished = operations.only(FinishRootBuildTreeBuildOperationType)
        buildFinished.progress.size() == 3
        buildFinished.progress.details.spans.text.flatten() ==~ ["buildA", "buildB", "buildC"].collect { "$message $it${getPlatformLineSeparator()}".toString() }

        where:
        description     | registration                                                          | message

    name: local-up-cluster
current-context: local-up-cluster
EOF

    # flatten the kubeconfig files to make them self contained
    username=$(whoami)
    ${sudo} /usr/bin/env bash -e <<EOF
    $(kube::util::find-binary kubectl) --kubeconfig="${dest_dir}/${client_id}.kubeconfig" config view --minify --flatten > "/tmp/${client_id}.kubeconfig"
    mv -f "/tmp/${client_id}.kubeconfig" "${dest_dir}/${client_id}.kubeconfig"

    }
    return res
}) // Results in a Collection[Endpoint]
```

As a rule of thumb, if your `Collection` type is a list, you most likely should be using a different type to flatten the list.
An exception to this would be if the list represents an atomic set of items that are never queried independently;
in these cases, however, it is probably best to wrap it in a struct.