https://kotlinlang.org
Join Slack
Is there any way by which, having a `List<String>` like this: ```val myList = listOf("paramA",...
# getting-started
d
Is there any way by which, having a 
List<String>
like this:
Copy code
val myList = listOf("paramA","paramB","paramC")
I can enforce an API like this?
Copy code
fun myFunc (paramA: String, paramB: String, paramC: String)
basically a function, which has those strings as names for String arguments?
v
?
d
@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.
e
how is that function coming into existence? if you're doing code generation, just generate it with the right parameter names?
v
Look towards reflection
d
Copy code
fun hello(nameA: String, nameB: String, nameC: String): Unit = TODO()

fun main() {
    val parmsName = ::hello.parameters.map{
        it.name
    }
    println(parmsName)
}
d
@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.
@derek thanks, but 
parameters
shows as “unresolved”
d
You should add kotlin reflect lib in your gradle project.
d
@derek I still cannot see it. Maybe it’s because I am on Multiplatform
e
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.
Copy code
val names = listOf(...)
val function = makeFunction(names)
even with something like that, 
function
has to have a type when it's declared, you can't change that at runtime
d
@ephemient yes, it makes sense. I will try to investigate other ways to achieve a similar solution, using Enum or Sealed Class. Thanks!
j
@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?
d
@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:
Copy code
"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”
j
That sounds to me like you would want to generate code, of which I am not sure how it looks like on kotlin multiplatform
because that makes me think you should create a compiler plugin
which looks rather cool but sadly also rather complicated 🙂
d
yes, I thought so
v
I think you're complicating something
j
I would definitely pass in a map or a list of pairs @Vitaliy Zarubin if I'd go that way :) just like in ktor
d
@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
also a Map doesn’t provide a great structure, but I guess it’s still easier than writing a compiler plugin
j
I would choose a map or vararg pair over writing a compiler plugin :)
d
yes, I think so too
v
r
if they are some kind of wierd IDs... why are they not some data structure?
eg, map, or maybe some fancy delegation trick with map
d
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.
r
if your only problem is getting data to/from string, then you could for example write custom format for #serialization
d
yes, that could actually be an option
I have never done, but is it possible to convert 
param1=value1&param2=value2&param3=value3
to 
MyDataClass(param1 = value1, param2 = value2, param3 = value3)
and back with Serialization?
considering that the data class is always different
r
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
d
@Roukanken thanks! it sounds like a great direction!
@Roukanken wow, thanks again! it solved my use case perfectly, much better than using the function I was thinking about!
Open in Slack
PreviousNext
Powered by

kotlinlang

A modern programming language that makes developers happier.

Powered by