* <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>
 * <li>don't guarantee allowing multiple threads dispatching</li>
 * </ul>
 */
public interface Connection<T> extends Dispatch<T>, Receive<T>, Stoppable {

import org.gradle.api.problems.internal.Problem;

import javax.annotation.Nullable;
import java.util.Collection;

/**
 * Used to signal the end of build to the plugin.
 *
 * Uses a specific listener to guarantee being invoked after user buildFinished callbacks.
 * Expected to be invoked once for a build tree.
 *
 * Implemented by the Enterprise plugin.
 */
public interface GradleEnterprisePluginEndOfBuildListener {

                    (sometimes the <replaceable>project.name</replaceable> is prefixed with parts of <replaceable>${project.path}</replaceable> to guarantee uniqueness).
                    Bear in mind that usually it is easier to use moduleName property instead of outputFile property.
                </td>
                <td/>
            </tr>
        </table>

            </thead>
            <tr>
                <td>name</td>
                <td><literal><replaceable>${project.name}</replaceable> (sometimes prefixed with parts of <replaceable>${project.path}</replaceable> to guarantee uniqueness)</literal></td>
            </tr>
            <tr>
                <td>comment</td>
                <td><literal>project.description</literal></td>
            </tr>
            <tr>

/**
 * A mapper that maps a {@link Throwable} thrown during test execution into a {@link TestFailure}.
 * <p>
 * Implementors of this class should not depend on classes outside the standard library, as there is no guarantee that they will be on the test VM's classpath.
 * Instead, they should rely completely on reflection.
 */
@NonNullApi
public abstract class TestFailureMapper {

    /**

 * instance contains a list of listeners, each with an associated {@code Executor}, and guarantees
 * that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link
 * #execute()} is called. Any {@code Runnable} added after the call to {@code execute} is still
 * guaranteed to execute. There is no guarantee, however, that listeners will be executed in the
 * order that they are added.
 *

 * instance contains a list of listeners, each with an associated {@code Executor}, and guarantees
 * that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link
 * #execute()} is called. Any {@code Runnable} added after the call to {@code execute} is still
 * guaranteed to execute. There is no guarantee, however, that listeners will be executed in the
 * order that they are added.
 *

../vendor/github.com/google/pprof.

Two important notes:

1. Using github.com/google/pprof directly (for example, after installing
with "go get") should work with Go programs, but we cannot guarantee that.
What we test is that the "go tool pprof" shipped with each Go release works
with programs from that release.

2. Pprof is used inside Google for C++, Java, and Go programs.

# Experimental C++ APIs for TensorFlow.
# New TF C++ APIs under the tensorflow::cc namespace aim to guarantee ABI stability.
# Users are expected to compile against public c++ headers, and link against
# libtensorflow (https://www.tensorflow.org/install/lang_c).
# We aim to achieve ABI stability in new C++ APIs by only using types
# on the API surface that:
# 1. Have a header-only implementation
# 2. Are std:: types
# 3. Wrap an opaque C type

        - label: "Does this affect error handling?"
        - label: "Is this about generics?"
        - label: "Is this change backward compatible? Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit"

  - type: textarea
    id: related-proposals
    attributes:
      label: Has this idea, or one like it, been proposed before?