return describers.stream()
            .filter(describer -> describer.canDescribeFailure(failure))
            .findFirst()
            .map(describer -> describer.describeFailure(failure, schema))

        Describer describer = new Describer();
        S service = Cast.uncheckedNonnullCast(factory.createBuildCacheService(configuration, describer));
        ImmutableSortedMap<String, String> config = ImmutableSortedMap.copyOf(describer.configParams);
        BuildCacheDescription description = new BuildCacheDescription(configuration, describer.type, config);

            }
        })
    }

    private class NoopBuildCacheDescriber implements BuildCacheServiceFactory.Describer {

        @Override
        BuildCacheServiceFactory.Describer type(String type) { this }

        @Override
        BuildCacheServiceFactory.Describer config(String name, String value) { this }

    }

    static class Writer implements BuildCacheEntryWriter {

                                          VersionParser versionParser
    ) {
        super(instantiatorFactory.decorateLenient(), authenticationContainer, objectFactory, providerFactory, versionParser);
        this.describer = describer;
        this.fileResolver = fileResolver;
        this.urlArtifactRepository = urlArtifactRepositoryFactory.create("Maven", this::getDisplayName);
        this.transportFactory = transportFactory;

    public List<AttributeDescriber> getConsumerDescribers() {
        return consumerAttributeDescribers;
    }

    @Override
    public void addConsumerDescriber(AttributeDescriber describer) {
        consumerAttributeDescribers.add(describer);
    }

    @Override
    public void attributeDisambiguationPrecedence(Attribute<?>... attributes) {
        for (Attribute<?> attribute : attributes) {

    }

    public MavenArtifactRepository createMavenRepository(Transformer<String, MavenArtifactRepository> describer) {

        DocsType.DOCS_TYPE_ATTRIBUTE,
        STATUS_ATTRIBUTE
    );

    /**
     * Checks if the given attribute is describable by this describer.
     *
     * @param attribute the attribute to check
     * @return {@code true} if the given attribute is describable by this describer; {@code false} otherwise
     */
    public boolean isDescribable(Attribute<?> attribute) {

            class ${className}ServiceFactory implements BuildCacheServiceFactory<${className}> {
                ${className}Service createBuildCacheService(${className} configuration, Describer describer) {
                    return new ${className}Service(configuration)
                }
            }
            class ${className}Service implements BuildCacheService {

func (b *B) Why() error   { return nil }
func (c *C) What() string { return "float64" }

func i_am_dead(c C) {
	var d describer = &c
	println(d.What())
}

func example(a A, b B) describer {
	if b == 1 {
		return &a
	}
	return &b
}

func ouch(a any, what string) string {
	cv := reflect.ValueOf(a).MethodByName(what).Call(nil)
	return cv[0].String()
}

func main() {

     * This method is kind of ugly.  If we could get a hold of the ResolutionFailureHandler in this class, we could use the typical
     * failure handling mechanism.  But we can't, so we have to throw the exception ourselves.  And as the describer
     * for this failure is abstract, we need to create an anonymous instance of it ourselves here, since there are
     * no instantiator types available here.
     *