Is it possible to use this outside of Kotlin, in particular I want to use this in a Scala app (but a Java example also suffices)

[DamianReeves]

Are there examples of how to use this outside of Android on the JVM? I'm interested in seeing if I can use this in my Scala CLI and server app.

[JakeWharton]

You can use the JS engine directly through the QuickJs type on any JVM language, but you'll be dealing with APIs that basically only deal in strings. In order to use the type-safe binding of interfaces on the host to implementations in the guest (what we call the JS), only Kotlin is supported as the binding is created using a Kotlin compiler plugin to rewrite the callsites.

[DamianReeves]

Do you mind pointing me to the Kotlin code in question, I may be able to use some Scala macro magic to simulate the idea.
Also are there any writeups or blogposts I can look at for examples?

[JakeWharton]

The Kotlin plugin itself is here: https://github.com/cashapp/zipline/tree/trunk/zipline-kotlin-plugin. Many of its internals will feature comments showing the shape of code that it is generating. It is very verbose internally because Kotlin IR is already verbose, but we're also generating some fairly complex things syntactically that require a lot of IR.

There are also multiple examples of what the class looks like after manipulation here:

zipline/zipline-testing/src/hostMain/kotlin/app/cash/zipline/testing/ZiplineTestInternals.kt

Lines 97 to 224 in 6f4a230

	/** Simulate a generated subclass of ZiplineServiceAdapter. */
	class EchoServiceAdapter : ZiplineServiceAdapter<EchoService>() {
	override val simpleName: String
	get() = "EchoService"
	override val serialName: String
	get() = "app.cash.zipline.kotlin.EchoService"
	override val serializers: List<KSerializer<*>>
	get() = emptyList()
	override fun ziplineFunctions(
	serializersModule: SerializersModule,
	): List<ZiplineFunction<EchoService>> {
	val requestSerializer = serializersModule.serializer(echoRequestKt) as KSerializer<*>
	val responseSerializer = serializersModule.serializer(echoResponseKt) as KSerializer<*>
	val name =
	"fun echo(app.cash.zipline.testing.EchoRequest): app.cash.zipline.testing.EchoResponse"
	return listOf<ZiplineFunction<EchoService>>(
	object : ReturningZiplineFunction<EchoService>(
	name.signatureHash(),
	name,
	listOf(requestSerializer),
	responseSerializer,
	) {
	override fun call(service: EchoService, args: List<*>): Any {
	return service.echo(args[0] as EchoRequest)
	}
	},
	)
	}
	override fun outboundService(callHandler: OutboundCallHandler): EchoService {
	return GeneratedOutboundService(callHandler)
	}
	private class GeneratedOutboundService(
	override val callHandler: OutboundCallHandler,
	) : EchoService, OutboundService {
	override fun echo(request: EchoRequest): EchoResponse {
	return callHandler.call(this, 0, request) as EchoResponse
	}
	}
	}
	/** Simulate a generated subclass of ZiplineServiceAdapter. */
	class GenericEchoServiceAdapter : ZiplineServiceAdapter<GenericEchoService<String>>() {
	override val simpleName: String
	get() = "GenericEchoService"
	override val serialName: String
	get() = "app.cash.zipline.kotlin.GenericEchoService<kotlin.String>"
	override val serializers: List<KSerializer<*>>
	get() = emptyList()
	override fun ziplineFunctions(
	serializersModule: SerializersModule,
	): List<ZiplineFunction<GenericEchoService<String>>> {
	val requestSerializer = serializersModule.serializer(stringKt) as KSerializer<*>
	val responseSerializer = serializersModule.serializer(listOfStringKt) as KSerializer<*>
	val name = "fun genericEcho(T): kotlin.collections.List<T>"
	return listOf<ZiplineFunction<GenericEchoService<String>>>(
	object : ReturningZiplineFunction<GenericEchoService<String>>(
	name.signatureHash(),
	name,
	listOf(requestSerializer),
	responseSerializer,
	) {
	override fun call(service: GenericEchoService<String>, args: List<*>): Any {
	return service.genericEcho(args[0] as String)
	}
	},
	)
	}
	override fun outboundService(callHandler: OutboundCallHandler): GenericEchoService<String> {
	return GeneratedOutboundService(callHandler)
	}
	private class GeneratedOutboundService(override val callHandler: OutboundCallHandler) :
	GenericEchoService<String>, OutboundService {
	override fun genericEcho(request: String): List<String> {
	return callHandler.call(this, 0, request) as List<String>
	}
	}
	}
	/** Simulate a generated subclass of ZiplineServiceAdapter. */
	class EchoZiplineServiceAdapter : ZiplineServiceAdapter<EchoZiplineService>() {
	override val simpleName: String
	get() = "EchoService"
	override val serialName: String
	get() = "app.cash.zipline.kotlin.EchoZiplineService"
	override val serializers: List<KSerializer<*>>
	get() = emptyList()
	override fun ziplineFunctions(
	serializersModule: SerializersModule,
	): List<ZiplineFunction<EchoZiplineService>> {
	val requestSerializer = serializersModule.serializer(echoRequestKt) as KSerializer<*>
	val responseSerializer = serializersModule.serializer(echoResponseKt) as KSerializer<*>
	val name =
	"fun echo(app.cash.zipline.testing.EchoRequest): app.cash.zipline.testing.EchoResponse"
	return listOf<ZiplineFunction<EchoZiplineService>>(
	object : ReturningZiplineFunction<EchoZiplineService>(
	name.signatureHash(),
	name,
	listOf(requestSerializer),
	responseSerializer,
	) {
	override fun call(service: EchoZiplineService, args: List<*>): Any {
	return service.echo(args[0] as EchoRequest)
	}
	},
	)
	}
	override fun outboundService(callHandler: OutboundCallHandler): EchoZiplineService {
	return GeneratedOutboundService(callHandler)
	}
	private class GeneratedOutboundService(override val callHandler: OutboundCallHandler) :
	EchoZiplineService, OutboundService {
	override fun echo(request: EchoRequest): EchoResponse {
	return callHandler.call(this, 0, request) as EchoResponse
	}
	}
	}

.

Another important thing to note is that the library relies on kotlinx.serialization which is itself a Kotlin compiler plugin that transforms code. So even if you mimic our transformation, there may still be transformations around serialization that are needed.