// CHECK: "tf.MapAndBatchDataset"(%[[TSLICE]], %[[BSIZE:.*]], %[[NPC]]
  // CHECK-SAME: f = @"__inference_Dataset_map_<lambda>_80",
  %4 = "tf.MapDataset"(%3) {device = "",
           f = @"__inference_Dataset_map_<lambda>_80",
           output_shapes = [#tf_type.shape<>], output_types = [i32],
           preserve_cardinality = false, sloppy = false,
           use_inter_op_parallelism = true,

    public LambdaImplementationSnapshot(HashCode classLoaderHash, SerializedLambda lambda) {
        this(
            lambda.getCapturingClass(),
            classLoaderHash,
            lambda.getFunctionalInterfaceClass(),
            lambda.getImplClass(),
            lambda.getImplMethodName(),
            lambda.getImplMethodSignature(),
            lambda.getImplMethodKind()
        );
    }

import java.lang.invoke.SerializedLambda
import kotlin.reflect.KClass


/**
 * In encoding a [SerializedLambda], this codec checks if the lambda parameter types are allowed in the configuration cache.
 * If some of them are not, it logs a problem.
 *
 * The lambda is encoded straightforwardly as a bean, and, upon decoding, the bean is expected to be the [SerializedLambda].

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

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

            public class MyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Function<String, String> lambda = s -> s.toUpperCase();
                    project.getExtensions().add("lambdaExtension", lambda);
                }
            }
            """
        )

        withBuildScript(
            """
            import java.util.function.Function

  // CHECK: "tf.MapAndBatchDataset"(%[[TSLICE]],
  // CHECK-SAME: f = @"__inference_Dataset_map_<lambda>_80",
  %5 = "tf.ParallelMapDataset"(%4, %3) {device = "",
           f = @"__inference_Dataset_map_<lambda>_80",
           output_shapes = [#tf_type.shape<>], output_types = [i32],
           preserve_cardinality = false, sloppy = false,
           use_inter_op_parallelism = true,

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, ":")