fun foo(lambda: (String) -> Int): Int = lambda("jello!")

fun test() {
    foo @Deprecated("") {<expr>
        it.length
    </expr>}

fun foo(lambda: (String) -> Int): Int = lambda("jello!")

fun test() {
    <expr>foo @Deprecated("") {
        it.length
    }</expr>

    override fun produceValueCaptor(lambdaType: KType): ConfigureLambdaHandler.ValueCaptor {
        lateinit var value: Any
        val lambda: Function1<Any, Unit> = { value = it }
        return ConfigureLambdaHandler.ValueCaptor(lambda, lazy { value })
    }

    private
    fun isConfigureLambdaType(maybeLambdaType: KType) = maybeLambdaType.isSubtypeOf(typeOf<Function1<*, Unit>>())

    private

		return ""
	}

	return "arn:minio:s3-object-lambda:" + arn.region + ":" + arn.TargetID.String()
}

// ParseARN - parses string to ARN.
func ParseARN(s string) (*ARN, error) {
	// ARN must be in the format of arn:minio:s3-object-lambda:<REGION>:<ID>:<TYPE>
	if !strings.HasPrefix(s, "arn:minio:s3-object-lambda:") {
		return nil, &ErrInvalidARN{s}
	}

	tokens := strings.Split(s, ":")

package lambda

import (
	"github.com/minio/minio/internal/config"
	"github.com/minio/minio/internal/event/target"
)

// Help template inputs for all lambda targets
var (
	HelpWebhook = config.HelpKVS{
		config.HelpKV{
			Key:         target.WebhookEndpoint,
			Description: "webhook server endpoint e.g. http://localhost:8080/minio/lambda",
			Type:        "url",
			Sensitive:   true,

    fun `adding function may have a configuring lambda if it returns the added value`() {
        val schema = schemaFromTypes(ReceiverOne::class, listOf(ReceiverOne::class))
        val function = schema.dataClassesByFqName.values.single().memberFunctions.single()
        assertIs<FunctionSemantics.AddAndConfigure>(function.semantics)
    }

    @Test
    fun `adding function may not have a configuring lambda if it returns Unit`() {

class ConfigurationCacheLambdaIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def fixture = new ConfigurationCacheFixture(this)

    def "restores task fields whose value is a #kind Java lambda"() {
        given:
        file("buildSrc/src/main/java/my/LambdaTask.java").tap {
            parentFile.mkdirs()
            text = """
                package my;

                import org.gradle.api.*;

fun foo(lambda: (String) -> Int): Int = lambda("jello!")

fun test() {
    <expr>foo</expr> @Deprecated("") {
        it.length
    }

        buildFile '''
            plugins { id("java") }
        '''
    }

    @NotYetImplemented
    @Issue("https://github.com/gradle/gradle/issues/19047")
    def "problem is reported for Kotlin lambda expression with develocity plugin"() {
        given:
        createDir('dv-conventions') {
            file('src/main/kotlin/my/DvConventionsPlugin.kt') << """
                package my

        write(original)

        expect:
        original == written
    }

    def "serializes lambda implementation properties"() {
        def lambda = TestLambdas.createTrackableLambda()
        def original = ImplementationSnapshot.of(lambda.getClass().name, lambda, TestHashCodes.hashCodeFrom(1234))
        write(original)

        expect:
        original == written
    }