Youssef Shoaib
Youssef Shoaib
Just clarifying, this would also be fine, right? ``` fun evalWhen(e: Expr): T = when (e) { is IntLit -> 42 } ```
From "Can we fix these problems": > Fundamentally, this means we may need to add ways to encode recursive types (aka µ types) or some other ways to propagate such...
@RossTate would this also basically allow existential types in subexpressions? What I mean is, Kotlin seems to have recently gained the ability to do something like: ```kotlin data class Foo(val...
Apologies for the tangential conversation @RossTate. Would something like ``` fun baz4(foo: Any) = when (foo of Any) { is Foo -> bar(foo.list, foo.set) else -> {} } ``` also...
Any info about when this'll be available as experimental? I have some advanced use cases I'd like to try with it (in particular, an interesting encoding of Higher-Kinded Types)
What's the plan with contract support? Will things "just work" out the box?
Does this feature also help when there isn't direct "subtyping" involved, but instead there's evidence given that a type parameter should be equal to some other type? Let me explain...
How does this deal with existential types? Let me demonstrate with an example: ```kotlin class Inv interface Expr class InvExpr(val t: T): Expr fun Expr.compose(other: Expr): Expr { if (this...
Since "Extension functions as static members" is allowed, I think we absolutely should allow static operators that can be imported as you'd expect. That would allow more controlled scoping of...
What printout are you getting, and what's your expected output?