quarkus/extensions/jsonb/runtime/pom.xml
quarkus/extensions/amazon-lambda-http/deployment/pom.xml
	quarkus/core/deployment/pom.xml
	quarkus/extensions/security/deployment/pom.xml
	quarkus/extensions/vertx-http/deployment/pom.xml
	quarkus/extensions/amazon-lambda/deployment/pom.xml
	quarkus/extensions/amazon-lambda-http/runtime/pom.xml
	quarkus/extensions/amazon-lambda-http/http-event-server/pom.xml

     */
    public static Supplier<Long> inThePast(int value, TimeUnit timeUnit) {
        // This needs to be an anonymous inner class instead of a lambda for configuration cache compatibility
        return new Supplier<Long>() {
            @Override
            public Long get() {
                return Math.max(0, System.currentTimeMillis() - timeUnit.toMillis(value));

                recurseDeeper(current.rhs)
                appendLine()
                appendIndented(")")
            }

            is FunctionArgument.Lambda -> {
                append("FunctionArgument.Lambda [${source()}] (\n")
                appendNextIndented("block = ")
                recurseDeeper(current.block)
                appendLine()
                appendIndented(")")
            }

 * someGraphAlgorithm(startNode, MyNode::getChildren);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the successors of a node, or one that doesn't
 * return an {@code Iterable<? extends N>}, then you can use a lambda to perform a more general
 * transformation:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, node -> ImmutableList.of(node.leftChild(), node.rightChild()));
 * }</pre>
 *

import kotlin.test.Test
import kotlin.test.assertEquals


object OverloadResolutionTest {
    @Test
    fun `function overloads with and without configure lambda are disambiguated`() {
        val schema = schemaFromTypes(MyTopLevelReceiver::class, listOf(MyTopLevelReceiver::class))

        val code = """
            addSomething(1)
            addSomething(1) { }

    }

    @Nullable
    @Override
    public Class<T> getType() {
        return valueType;
    }

    @Override
    public ValueProducer getProducer() {
        // not a lambda for readability purposes.
        //noinspection Convert2Lambda
        return new ValueProducer() {
            @Override
            public void visitProducerTasks(Action<? super Task> visitor) {

    def "class can include only serializable lambda"() {
        given:
        def cl = transformAndLoad(ClassWithSerializableLambda, ClassWithSerializableLambda.SerializableThing)

        expect:
        def original = cl.thing(123)
        def result = recreate(original).call()

        result == "123"
    }

    def "interface can include only serializable lambda"() {
        given:

		configLogIf(ctx, fmt.Errorf("Unable to initialize notification target(s): %w", err))
	}

	bootstrapTraceMsg("initialize the lambda targets")
	globalLambdaTargetList, err = lambda.FetchEnabledTargets(GlobalContext, s, transport)
	if err != nil {
		configLogIf(ctx, fmt.Errorf("Unable to initialize lambda target(s): %w", err))
	}

	bootstrapTraceMsg("applying the dynamic configuration")
	// Apply dynamic config values

                )
            )
            FunctionCall [indexes: 12..33, line/column: 2/1..2/22, file: test] (
                name = f
                args = [
                    FunctionArgument.Lambda [indexes: 14..33, line/column: 2/3..2/22, file: test] (
                        block = Block [indexes: 16..31, line/column: 2/5..2/20, file: test] (
                            ErroneousStatement (

        val resolver = tracingCodeResolver()

        val topLevelBlock = parseAsTopLevelBlock(
            """
            addAndConfigure("correct") { }
            addAndConfigure("lambda missing")
            addAndConfigure("incorrect signature", 1) {
                number = 123