To make it more idiomatic in Kotlin one could introduce an extension overload

from(lazySource: Lazy<Any>)

that would wrap lazy into callable.

unfortunately extensions cant take precedence over declared members, at least there’s no mechanism available currently

and they shouldn't

not by default, I agree

i’m not sure ever, really

that doesn’t mean there shouldn’t exist a mechanism to explicitly allow specific extensions to take precedence

we (Gradle Kotlin team) would certainly love to have that capability to make Gradle APIs more idiomatically consumable from Kotlin

that would allow, for instance, to provide extensions accepting

T.() -> Unit

where the original functions are declared to accept

Action<T>

@ilya.gorbunov: that makes sense. That still leaves room to make the actual implementation type (the one returned from

lazy

) to implement it, how does that sound?

That's possible, but looks like a quite ad-hoc solution )

it does )

@kittinunf has left the channel

Why is String with Int concatenation not symmetric?

println("test" + 1)
println( 1 + " test")

The second line is invalid code because String defines an generic plus

kotlin.String.plus

whereas Integer does not do so. This feels odd, especially since Java does both.

doesn't even know where one would use both of those

string interpolation is just soooo much better

also, concatenation really fucks up any hope of i18n

@holgerbrandl: Why should it be symmetric? it is not in Java either

the result isn’t symmetric, but the operator behaves the same in either case— it toStrings the int and concatenates

one fix:

operator fun Int.plus(str: String): String = toString() + str

it is surprising to Java developers

there was

operator fun Any?.plus(String): String

at some point but it was deleted for several reasons, one of them was I believe that it clashed with

+

for lists:

listOf(“a”) + “b”

should return list of “a” and “b”, not a string

[a]b

yes, and there was problems around

null + ...

So why is

operator fun Int.plus(str: String): String = toString() + str

not part of the stdlib? It seems rather common to me. I see why you don't like extensions on

Any?

It seems to be missing at least for me when using v1.0.2

Another two considerations against

Any?.plus(String)

operator: - we prefer to have as few extensions for

Any?

type or unconstrained generic

T

as possible. -

plus

operation tries its best to preserve the form of the first operand, so that

List + T

is

List

,

String + Any?

is

String

,

Sequence + List

is

Sequence

, etc

do we have considerations against more specific functions like

fun Number.plus(str: String) = toString() + str

?

No, but the second consideration about

plus

is still valid.

yes, the second is important so

plus

and

plusAssign

looks consistent so that

val s = a + b

var s = a
s += b

wouldn't work if we break this rule