Hey everybody, Thanks for having me. Can somebody ...

# announcements

[jim]

Hey everybody, Thanks for having me. Can somebody tell me how to resolve this ambiguity without it. ?

kotlin
        val a = "1 2\n3 4".lines().map{CharSequence::split("\\s+".toRegex())}

log
Matrix.kt: (10, 59): This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)
e: /home/a/github/exercism/kotlin/matrix/src/main/kotlin/Matrix.kt: (10, 54): Overload resolution ambiguity:
public fun CharSequence.split(regex: Pattern, limit: Int = ...): List<String> defined in kotlin.text
public fun CharSequence.split(vararg delimiters: String, ignoreCase: Boolean = ..., limit: Int = ...): List<String> defined in kotlin.text
public fun CharSequence.split(vararg delimiters: Char, ignoreCase: Boolean = ..., limit: Int = ...): List<String> defined in kotlin.text
@InlineOnly public inline fun CharSequence.split(regex: Regex, limit: Int = ...): List<String> defined in kotlin.text

[nanodeath]

is it a method reference or a method call? you can't do both

[jim]

well, I have tried different things

val a = "1 2\n3 4".lines().map(CharSequence::split("\\s+".toRegex()))

isn't working either.

[jim]

And I saw

fun scoreWord(word: String): Int {
        if(word.isEmpty()) return 0

        return word
            .map(Character::toUpperCase)
            .map { scores.getOrDefault(it, 0) }
            .reduce(Int::plus)
    }

[nanodeath]

I mean `Class::method(`is never going to work

[jim]

Sorry, I am new to this. isn't Character::toUpperCase Class::method?

[nanodeath]

yes, but there's no attempted method invocation there -- that ( I added isn't a typo

[nanodeath]

btw .map(Character::toUpperCase) is exactly equivalent to .map { it.toUpperCase() } or, more verbosely, .map { c: Character -> c.toUpperCase() }

[nanodeath]

I don't think there's any way around doing this:

val spaces = "\\s+".toRegex()
val a = "blah".lines().map { it.split(spaces) }

[jim]

right, right, I was looking to the equivalent thing to map{it.split("\\s+".toRegex())}.

[jim]

And you are saying it doesn't work because split takes 1 parameter, right?

[nanodeath]

if split returned a (Character -> T) instead of a String, you could probably say map(it.split("\s"))

[nanodeath]

but yeah, split accepts one parameter, and that parameter isn't the string being split; it's the pattern you want to split on, which is crucial

[Quincy]

You could maybe do something like this?

val spaces = "\\s+".toRegex()
val spliter = { s: String -> s.split(spaces) }
val a = "blah".lines().map(splitter)

But if the actual use case is not more complicated than what you've shown it's not really buying you anything.

[jim]

ok, I don't think I understand if .map(Character::toUpperCase) gets translated to .map { c: Character -> c.toUpperCase() } , why .map(CharSequence::split("\\s+".toRegex()) is not translated to .map{cs:CharSequence -> cs.split("\\s+".toRegex())} . I just mark it as one parameter extra. Does not work. Thank you for the replies.

[nanodeath]

it's just invalid syntax. you can't combine a method reference with a method invocation.

[nanodeath]

@Quincy yeah, that would work. might also promote the splitter thing into an actual method; that might be more efficient

[Quincy]

@Ol' Dawg a reference like Character::toUppercase is a way of referring to a specific function defined elsewhere which satisfies the type (Character) -> Character

[Roukanken]

Disclaimer: please really don't do this, I'm just messing with stuff
https://pl.kotl.in/IF5TTwTJm this actually works

the obvious question is why do mySplit ? ... well original split has like 4 overloads and compiler complains it can't chose. Afaik, doing this is stretching the limits of Kotlin's type system


anyways, to real question: Map can only handle if you pass it reference to function taking 1 argument - because it has 1 value (the it ) and can just chunk it there. But split needs at least 2 arguments - a.split(b) both a and b are arguments, and map only has 1 value.
And no, you can't just pass 1 argument to reference and expect a new function to be created (sadly)

[Nir]

I'm not really sure what partial buys you here

[Roukanken]

nothing 😛 Just wanted to try if that would work even
I'm all for just specifying it - you won't get clearer than that

if he hates to use it then easy solution: name it

[Nir]

"blah".lines().map { it.split("\\s+".toRegex()) }

Already works and is perfectly readable, the problem is that you'd be executing the toRegex over and over

[Nir]

Which is a problem shared by the solution you posted

[Nir]

The ugliest part of the kotlin solution is that you have to create this spaces variable but it's not clear how you'd hope to avoid that in general.

[Roukanken]

the partial solution mess wouldn't actually call toRegex over and over - it passes the function just once to map, with already "inlined" argument

but without managing to resolve that overload ambiguity, it's not really viable solution

[Nir]

Ah you're totally right, my bad

[Nir]

Probably not recommended either but a way to make it work as a one liner, without any extra machinery:

val a = "1 2\n3 4"
        .lines()
        .map("\\s+".toRegex().let{ {line -> line.split(it)} })

[wbertan]

It seems Regex already has a split . Can check if the output is desirable, but could try this:

val a = "1 2\n3 4".lines().map("\\s+".toRegex()::split)

The docs says:

Splits the input CharSequence around matches of this regular expression.

So I believe it should work as expected.