A modern programming language that makes developers happier.

kotlinlang

Hi, what is the “nicest” way to partially apply more than a few parameters?

I know about two options:
```val renderSmsTemplate: RenderSmsTemplate = ::renderTemplate.curried()(
        generateCommandId
)(
        generateMessageId
)(
        getNow
)(
        TopicName(TEMPLATE_COMMANDS_TOPIC)
)(
        TemplateId(templateId)
)

val sendSms: SendSms = ::sendSms
        .partially1(generateCommandId)
        .partially1(generateMessageId)
        .partially1(getNow)
        .partially1(TopicName(SMS_COMMANDS_TOPIC))```

Generally each function has the first parameters that are dependencies and the rest are actual parameters that are defined by some interface/type alias.

What I’m looking for is to apply a few leading parameters. Ideally:
```::sendSms.partially(generateCommandId, generateMessageId, getNow, TopicName(xx))```


that’s the most interesting brackets i’ve seen in a long time :sweat_smile:

I have not found any other way to break the line :slightly_smiling_face:

Hi, In the past I evaluated also the syntax
```(::sendSms)(generateCommandId, generateMessageId, getNow, TopicName(xx))```
but maybe the most idiomatic way to do it in kotlin (one that every kotlin dev can understand immediately) is just
```{ sendSms(generateCommandId, generateMessageId, getNow, TopicName(xx)), it) }```

or better
```{ templateId -&gt; sendSms(generateCommandId, generateMessageId, getNow, TopicName(xx)), templateId) }```

The issue is that you might have 5 other different parameters after that, or even worse you're gonna need to specify type parameters for them all.

I think just like how curried is defined we can also define a partial-application `invoke` that returns ethe appropriate function, but this'll potentially need a huge amount of definitions

If you already have the curried version of the function, you could write a generalized `uncurry4` function to partially apply the first 4 parameters in a single call.
```fun &lt;A,B,C,D,R&gt; ((A)-&gt;(B)-&gt;(C)-&gt;(D)-&gt;R).uncurry4(): (A,B,C,D)-&gt;R = 
{ a: A, b:B, c:C, d:D -&gt; 
    this(a)(b)(c)(d) 
}```

I was thinking about adding overloaded `partially` function that would apply `n` first arguments for all arities (1 - 22). But that means 253 * 2 functions (regular &amp; suspend). I’m not sure if IDEA would be happy with that :slightly_smiling_face:.

It’s sad that partial application is not supported by Kotlin.