is there something like `public fun String.substri...

# stdlib

[christophsturm]

is there something like `public fun String.substringAfter(delimiter: String, missingDelimiterValue: String = this)`` that instead returns null if the delimeter is not found?

[spand]

Strange that the type of missingDelimiterValue isnt String?

[ephemient]

it isn't type String? because then every use would have have to deal with potential null result

[spand]

Only if you pass in a null ie. fun <R : String?> String.substringAfter(..., missingDelimiterValue: R = this) : R

[spand]

Same as all the others that take a default value (ie. getOrDefault() for a map)

[ephemient]

Map.getOrDefault mirrors a Java API and requires @UnsafeVariance due to being in in+out position. Kotlin stdlib methods take a lambda for default, e.g. getOrElse

[ephemient]

note that you can't actually define fun <R : String?> String.substringAfter(..., missingDelimiterValue: R = this) : R, give it a shot and you'll see

ERROR Type mismatch: inferred type is String but R was expected

[ephemient]

what you want is that R is a supertype of String?, not a subtype, but that can't be expressed

[christophsturm]

no, R is either String? or String so its a subtype

[christophsturm]

private  fun <R:String?> String.substringAfter(delimiter: String, default:R): R {
    val index = indexOf(delimiter)
    return if (index == -1) default else substring(index + delimiter.length, length) as R
}

fun main() {
    val nullable : String? = "nullable".substringAfter("null", null)
    val nonNullable : String = "nullable".substringAfter("null", "notNull")
}

this works

[ephemient]

mapOf<String, String>("a" to "b").getOrElse("c") { 0 } is Any works

[ephemient]

string.ifEmpty { charSequence } works

[ephemient]

supertypes should be the solution, it just can't be expressed in Kotlin

[christophsturm]

image.png

[christophsturm]

the method acts exactly as it should

[spand]

I stand corrected. Thats what you get for not trying it out 😉

[christophsturm]

so whats wrong with the cast? the method is just as type safe as the not nullable method or what am I missing?

[spand]

I think your version is fine. You just sacrificed the default value for the parameter to do it.

[christophsturm]

oh lol i totally missed that. without default parameter it does not make much sense

[christophsturm]

I’ll just keep using my own subStringAfterOrNull

[christophsturm]

I still don’t undestand why it needs the cast at all and why r should be a supertype

[christophsturm]

also whats wrong with this?

fun <R:String?> String.substringAfter(delimiter: String, default:R = this as R): R {
    val index = indexOf(delimiter)
    return if (index == -1) default else substring(index + delimiter.length, length) as R
}

[christophsturm]

default parameters can be cast too

[ephemient]

it can't handle .substringAfter("", charSequence). the existing method can't either, but Kotlin's other get-or-else all handle similar cases fine

[ephemient]

ideally something like

inline fun <R> String.substringAfter(delimiter: String, default: () -> R): R where String : R = ...
fun String.substringAfter(delimiter: String): String = substringAfter(delimiter) { this }

but that where clause is not legal

[christophsturm]

ok but thats a seperate issue from the nullability

[christophsturm]

fun <R:CharSequence?> CharSequence.substringAfter(delimiter: String, default:R = this as R): R {
    val index = indexOf(delimiter)
    return if (index == -1) default else substring(index + delimiter.length, length) as R
}

[spand]

I think you should submit an issue with the improved version:

fun <R:String?> String.substringAfter(delimiter: String, default:R = this as R): R