You would need to define a custom

operator fun contains

object Links {
    <values here>

    operator fun contains(link: String) = when (link) {
        HELP, SHOP, BLOG, ... -> true
        else -> false
    }
}

I’m having a hard time thinking of a convenient way of providing that logic though - you could maybe add all the constants to a hashset or something and update it every time you added or removed a constant but that’s kinda annoying, or use a big

when

but similar issue

I added an example of a when, but yeah, there's no way without listing off the values.

Thanks!

I was considering maybe recommending using an enum and using

.values()

but that’s problematic for other reasons

Indeed

How about something like this:

object Links {
    private val values = mutableSetOf<String>()
    private operator fun String.unaryPlus(): String = this.also { values += it }

    val HELP = +"https://..."
    val SHOP = +"https://..."
    val BLOG = +"https://..."
    val GALLERY = +"https://..."

    operator fun contains(string: String) = string in values
}

Nice! Maybe a hair overengineered but that’s pretty clever 👍

That still requires remembering the

+

(or some other function call), and means you can't have the values be

const

.

Lets say I have "help.123.com/help_me" as the only item in values and I check for "help.123.com" in values would that return false?

@Ruckus true, not a perfect solution - it’d suck to have a test fail because you accidentally forgot to add a

+

at the start of a constant

It would return false. For that logic you would need to augment the

contains

implementation. My snippet was just how you might handle the boilerplate. @Ruckus definitely some downsides to using the

+

. I was just going for something non-intrusive. The only alternative I can think of would require reflection or a lot more boilerplate (or enums as someone else mentioned)

@Jake yes, that

in

check would return false, it’s just a simple

equals

call

Perfect. You guys rock.

@kz Your solution was pretty slick, don't get me wrong. I don't mean to throw it out, just point out the trade-offs to make an informed decision.

🙂 I definitely agree.

@Jake you could declare the links in an enum instead of an object and then check with

Links.values().any { ... }