I’d like to combine multiple of these, like a when expression.

So that the first match that produces non-null passes the parsed value to a block of code

Similarly to how an

is

clause in a

when

expression matches a value and lets a block of code use it as a down-case value of a more concrete type, I’d like to hook my parsers into the

when

expression to match a string and use it as a parsed value.

I’m thinking that there could be a convention by which the

when

expression uses operator functions to match and cast using branches of the when

any news on https://youtrack.jetbrains.com/issue/KT-6728 (Suggestion: Allow constraint for reified type parameter to have zero-arg constructor)? If not, consider this a friendly bump

why is explicit initializer required for a nullable property ? Why not default to null ?

var allByDefault: Int? // error: explicit initializer required, default getter and setter implied

because Kotlin favors explicit over implicit

re KT-6728 - why not just use function and pass a reference to the constructor you want to call? E.g.

class Banana {
}

val factory : () -> Banana = ::Banana
val newBanana = factory()

because it makes the signature of the function longer and involves generating an additional class

I don’t actually believe in friendly bumps, especially when it comes to language design. It doesn’t work like this simple smile

interesting, how would you like to see the discussion go about issues that didn't receive activity in some time?

We are working on a community process, formally defined, with templates and such. This is essential for language evolution, so it can be discussed in open, and still not get lost and have an acceptable noise/signal ratio.

that's good to hear

I hope function delegation comes up soon

@dzaitsev has left the channel

Probably a long-shot, and feel free to shoot it down. Would you guys at JetBrains be opposed to implementing our

singleAssign()

delegate as part of the Kotlin standard library? Our implementation is here on the TornadoFX project(https://github.com/edvin/tornadofx/blob/master/src/main/java/tornadofx/Properties.kt#L52:L115). It allows making a property assignable only once and I've found it much more effective than

lateinit

since it locks down mutability and threading problems (unless you pass parameters to make it unsynchronized like

lazy()

)

sounds like

notNull

to me. What's the difference?

notNull

can be assigned multiple times

Yeah, that is correct. Here's our documentation. https://github.com/edvin/tornadofx/wiki/Properties#single-assign-property

@thomasnield:

initOnce

delegate is considered under https://youtrack.jetbrains.com/issue/KT-7180. Feel free to upvote.

Cool thanks, will do.

Moving from #C0922A726: What do you think about allowing definition of a method on optional type? Just like I can define an extension function:

fun MyClass?.myFunction() = ...

I was thinking about something like:

class MyClass {
    fun ?myFunction() = ...
}

what about putting in the companion object?

@dh44t: I had no success calling such function defined in companion object the same way extension function would be called. (outside of MyClass:)

val myObject: MyClass? = ...
myObject.myFunction()

@mg6maciej: (moving from #C0922A726 ) how do you suggest to implement it?

@voddan: The most straighforward implementation would be to treat it as syntactic sugar for extension function. But maybe it's not worth it at all.

ok, i see

what are the benefits?

The root cause of me wondering if that's possible is that IDEA doesn't show a file as a kotlin class when there is something else defined below the class (extension function here).

haha, have that problem too