@FunctionalInterface
    public interface UserTypeSupplier {
        OptionalThing<String> supply();
    }

    @FunctionalInterface
    public interface UserBeanSupplier {
        OptionalThing<FessUserBean> supply();
    }

    @FunctionalInterface
    public interface AppTypeSupplier {
        String supply();
    }

    // ===================================================================================

            return getter.get().add(revMapper.apply(t));
        }
    }

    @Override
    public T set(int index, T element) {
        Objects.requireNonNull(element);
        if (setter != null) {
            List<U> list = new ArrayList<>(getter.get());
            U ret = list.set(index, revMapper.apply(element));
            setter.accept(list);
            return mapper.apply(ret);
        } else {

            final DefaultQueryBuilderFunction builder) {
        final BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.should(builder.apply(fessConfig.getIndexFieldTitle(), fessConfig.getQueryBoostTitleAsDecimal().floatValue()));
        boolQuery.should(builder.apply(fessConfig.getIndexFieldContent(), fessConfig.getQueryBoostContentAsDecimal().floatValue()));

ExtensionReceiver[name: apply; isMutated: false; displayText: this@apply]
    apply@fun R|Foo|.<anonymous>(): R|kotlin/Unit| <inline=Inline, kind=EXACTLY_ONCE>

                    Object key = getPluginKey().apply(element);
                    master.put(key, element);
                }

                Map<Object, List<Plugin>> predecessors = new LinkedHashMap<>();
                List<Plugin> pending = new ArrayList<>();
                for (Plugin element : src) {
                    Object key = getPluginKey().apply(element);
                    Plugin existing = master.get(key);

                for (Plugin element : src) {
                    Object key = getPluginKey().apply(element);
                    managedPlugins.put(key, element);
                }

                List<Plugin> newPlugins = new ArrayList<>();
                for (Plugin element : target.getPlugins()) {
                    Object key = getPluginKey().apply(element);
                    Plugin managedPlugin = managedPlugins.get(key);

    private SearchEngineUtil() {
    }

    public static OutputStream getXContentBuilderOutputStream(final XContentBuilderCallback func, final MediaType mediaType) {
        try (final XContentBuilder builder = func.apply(mediaType.contentBuilder(), ToXContent.EMPTY_PARAMS)) {
            builder.flush();
            return builder.getOutputStream();
        } catch (final IOException e) {
            if (logger.isDebugEnabled()) {

        project.apply {
            registerService(KotlinLifetimeTokenProvider::class.java, KotlinReadActionConfinementLifetimeTokenProvider::class.java)
        }
    }

    override fun registerApplicationServices(application: MockApplication, testServices: TestServices) {
        application.apply {

    @Test
    void testDefaultPolicy() throws Exception {
        MetadataGraphEdge res;

        res = policy.apply(e1, e2);
        assertEquals("1.1", res.getVersion(), "Wrong depth edge selected");

        res = policy.apply(e1, e3);
        assertEquals("1.2", res.getVersion(), "Wrong version edge selected");
    }

): KaType =
    analysisSession.typesCreator.buildClassType(KaClassTypeBuilder.ByClassId(classId, token).apply(build))

public inline fun KaTypeCreatorMixIn.buildClassType(
    symbol: KaClassLikeSymbol,
    build: KaClassTypeBuilder.() -> Unit = {},
): KaType =
    analysisSession.typesCreator.buildClassType(KaClassTypeBuilder.BySymbol(symbol, token).apply(build))

public inline fun KaTypeCreatorMixIn.buildTypeParameterType(