Is there any way by which, having a

List<String>

like this:

val myList = listOf("paramA","paramB","paramC")

I can enforce an API like this?

fun myFunc (paramA: String, paramB: String, paramC: String)

basically a function, which has those strings as names for String arguments?

?

@Vitaliy Zarubin thanks, that’s nice However I was looking for something slightly different. So, I would like to make available a function which has exactly those parameters. So that a library user is able to type “`myFunc()`” and the IDE shows the arguments to provide to such function. So basically a standard function, with those argument names. Not sure if the power of Kotlin allows this.

how is that function coming into existence? if you're doing code generation, just generate it with the right parameter names?

Look towards reflection

@ephemient so, basically I would like a library user to define those parameters as a List<String>, and based on that I would like to automatically provide the library user with a function with such signature. But not sure if it's possible.

You should add kotlin reflect lib in your gradle project.

@derek I still cannot see it. Maybe it’s because I am on Multiplatform

so. there's no cross-platform options for reflection and runtime code generation at this level. but even on JVM, I'm not sure how you imagine this could possibly work.

@ephemient yes, it makes sense. I will try to investigate other ways to achieve a similar solution, using Enum or Sealed Class. Thanks!

@Daniele B what do you wish to achieve with this? Why do you want to generate a function from a list, and what is that function in term supposed to do?

@Joost Klitsie I need to define an ID with this String format:

"param1=value1&param2=value2&param3=value3"

Where the number and the names of the params should be defined by the library user. e.g. this could be all possibile IDs:

"country=Belgium"

"listType=ALL&filter=name"

"id=203"

So, I want to give the chance to the library user to hardcode the parameter names, and then being able to populate each of them with a simple function. This ID should be univocally identified as the String format I mentioned above: “param1=value1&param2=value2&param3=value3”

That sounds to me like you would want to generate code, of which I am not sure how it looks like on kotlin multiplatform

yes, I thought so

I think you're complicating something

I would definitely pass in a map or a list of pairs @Vitaliy Zarubin if I'd go that way :) just like in ktor

@Vitaliy Zarubin this assumes the parameters are specified as free text: “param1=value1&param2=value2&param3=value3” but this could be very error prone ideally, the library should help by providing a solid structure to specify the parameters

I would choose a map or vararg pair over writing a compiler plugin :)

yes, I think so too

You have 3 options: 1. make the method universal ~ https://kotlinlang.slack.com/archives/C0B8MA7FA/p1620811561035400?thread_ts=1620804243.027000&amp;cid=C0B8MA7FA 2. use reflection - https://kotlinlang.org/docs/reflection.html 3. generate code - https://github.com/square/kotlinpoet

if they are some kind of wierd IDs... why are they not some data structure?

The problem with defining a data structure such as a data class, is that I don’t know how to convert “`param1=value1&param2=value2&param3=value3`” back to the data class. But with Map of course it’s easy.

if your only problem is getting data to/from string, then you could for example write custom format for #serialization

yes, that could actually be an option

as long as you know what class is stored in the string, yes for sure - that's basically JSON format just different separators and stuff, so custom format would be able to handle it if you don't, and don't mind changing the string a bit, (eg,

type=MyDataClass&param1=value1&param2=value2&param3=value3

) then it should be possible too I haven't looked into custom formats too deep yet tho... Here is some reading for it: https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/formats.md

@Roukanken thanks! it sounds like a great direction!