Kotlin - conditional chaining of methods

Question

Is there a way to chain optionally a method in Kotlin, like for example on a FuelManager class, where I would like to have body method as an optional thing, so this would be a request with a body method:

val (_, response, data) = manager .request(Method.POST, url) .timeoutRead(2_000) .timeout(1_000) .header("Content-Type" to "application/json") .header("X-API-Key" to ctx.conf.get(ConfValues.ApiSecret)) .body(payload.toString()) .responseString()

So, here I would like to check if payload exists, then I would add body method, if not I would not add body to a request. Request without body method.

val (_, response, data) = manager .request(Method.POST, url) .timeoutRead(2_000) .timeout(1_000) .header("Content-Type" to "application/json") .header("X-API-Key" to ctx.conf.get(ConfValues.ApiSecret)) .responseString()

See this. Consider using apply instead of chaining. This way you can put if statements wherever you like. Is each of the chained methods declared in the same type? — Sweeper
– Sweeper, Commented Sep 17, 2021 at 12:20

Roland · Accepted Answer · 2021-09-17 12:51:54Z

I agree with Sweepers comment, that apply may be nicer to use here, e.g.:

val (_, response, data) = manager.apply { request(Method.POST, url) timeoutRead(2_000) timeout(1_000) header("Content-Type" to "application/json") header("X-API-Key" to ctx.conf.get(ConfValues.ApiSecret)) if (!payload.isNullOrBlank()) body(payload.toString()) }.responseString()

Inserting an if-statement is relatively straight-forward in that case.

If you can't trust that what you have follows fluent API best practice (i.e. returning the actual instance again), you may instead use also something as follows:

val (_, response, data) = manager .request(Method.POST, url) .timeoutRead(2_000) .timeout(1_000) .header("Content-Type" to "application/json") .header("X-API-Key" to ctx.conf.get(ConfValues.ApiSecret)) .let { if (!payload.isNullOrBlank()) it.body(payload.toString()) else it } .responseString()

I.e. putting the if-statement inside the scope functions let or run.

Drat, you beat me to it by 3 mins :-) Yes, let() is the most direct solution here — though, as others have said, these long chains are hard to read and maintain, so there are better approaches.

lambda dude · Accepted Answer · 2021-09-17 12:39:59Z

I think this should do the job

val (_, response, data) = manager .request(Method.POST, url) .timeoutRead(2_000) .timeout(1_000) .header("Content-Type" to "application/json") .header("X-API-Key" to ctx.conf.get(ConfValues.ApiSecret)) .apply { if(!payload?.toString().isNullOrBlank()) { body(payload.toString()) } } .responseString()

See https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/apply.html

cactustictacs · Accepted Answer · 2021-09-17 22:31:10Z

Like people have said, long chains can be hard to read (especially if you start adding a bunch of logic into them), so it might be better to break it down into some well-named functions instead

val (_, response, data) = manager.apply { request(Method.POST, url) timeoutRead(2_000) timeout(1_000) header("Content-Type" to "application/json") header("X-API-Key" to ctx.conf.get(ConfValues.ApiSecret)) addBodyIfRequired(payload) }.responseString() private fun WhateverManager.addBodyIfRequired(payload: Payload) = apply { if (!payload.isNullOrBlank()) body(payload.toString()) }

That way it reads a little clearer, and if you ever need to tweak the logic it can happen in that separate function, and your builder still looks nice and clean. You tend to see this kind of thing in functional programming, where you can have long pipelines of operations, but you create small functions you can chain together in a neat and readable way

Plus with extension functions, you can kinda rewrite how the builder looks - say if you wanted to combine the two timeout calls into one, with named parameters. It's definitely a personal preference thing, but it can really help when there's a lot happening and you want to keep it concise!

Arthur Khazbulatov · Accepted Answer · 2023-09-01 12:56:31Z

If you tend to often write code like:

something .let { if (condition1) block1(it) else it } .let { if (condition2) block2(it) else it }

I suggest adding these custom scope extension functions to your arsenal:

inline fun <T> T.letIf(condition: Boolean, block: (T) -> T): T = if (condition) this.let(block) else this inline fun <T> T.runIf(condition: Boolean, block: T.() -> T): T = if (condition) this.run(block) else this inline fun <T> T.alsoIf(condition: Boolean, block: (T) -> Unit): T = if (condition) this.also(block) else this inline fun <T> T.applyIf(condition: Boolean, block: T.() -> Unit): T = if (condition) this.apply(block) else this

Then you could use them like this:

import my.cool.extensions.letIf something .letIf (condition1) { block1(it) } .letIf (condition2) { block2(it) }

Marit · Accepted Answer · 2021-09-17 12:19:25Z

0

You can use isNullOrBlank() "Returns true if this nullable char sequence is either null or empty or consists solely of whitespace characters."

answered Sep 17, 2021 at 12:19

Marit

3,2061 gold badge23 silver badges33 bronze badges

2 Comments

Leff Over a year ago

How can I use that for my case where I would not add body method call if payload doesn't exists?

Marit Over a year ago

with the apply { if } from the answer by lambda dude

Collectives™ on Stack Overflow

Kotlin - conditional chaining of methods

5 Answers 5

1 Comment

Comments

Comments

Comments

2 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

Comments

Comments

Comments

2 Comments

Linked

Related