@karelpeeters uploaded a file:

Yay glad to hear that, I was expecting random API in Kotlin for a long time now, thank you

I have a small request, actually I can retrieve the value of a variable reference (

KMutableProperty0<R>

) with the

invoke

operator

val a = ref()

Are there any thoughts about creating range implementations that support endExclusive behavior, particularly for Doubles? I have a large need for this to bin items based on double values.

Is there any way we could redefine

equals

for a JDK class? Comparing

JSONObject

drives me nuts!

you can use Guava's Equivalence.Wrapper if you're using a map or set. but otherwise if that's org.json i would recommend not using it in the first place

Maybe there's no choice between using it or not using it

then keep going popping things off the stack until you reach that choice

I mean, maybe it's already in a somewhat legacy project and it's already this way. Might be way too expensive to migrate to another tool

I was hoping for some compiler trick that we could do on the stdlib level and repair org json

Dang it, I'm trying to implement an

OpenRange

for a KEEP. I am trying to figure out if it's possible to mix

ClosedRange

and

OpenRange

. However, due to @ilya.gorbunov's citation of abandoning a general

Range

parent, this is not possible.

@thomasnield uploaded a file: Untitled

KEEP is now filed for Closed Ranges and a Range Interface

(moved from #language-proposals)

Maybe try to add to kotlin.reflect a field that returns the wrapper name of an inline class? (if class C is an inline class then it will return the inline class name else it will return simpleName) This could be used in order to detect if an integers is signed of unsigned for example I would like to get feedback about this idea Thanks for the hard work by now

val x  = 6022u
println(x::class.wrapperSimpleName)
println(x::class.wrapperQuilifiedName)

I think I have found a bug when using an inline class that contains an inline class:

@ExperimentalUnsignedTypes
fun main(args: Array<String>) {
    val x = Id(1212u)
    println(x)
    println(x::class.simpleName)
}

@ExperimentalUnsignedTypes
@Suppress("EXPERIMENTAL_FEATURE_WARNING")
inline class Id(private val v: UInt)

Gives me this output:

org.aregevdev.kotlinstuff.Id@2503dbd3
Int

Expected to print the actual Int value, not the java object string deceleration

Shouldn't it pick the

println(Any)

overload and thus box the value?

I dont know, this is odd

Well try it with a normal inline class simple smile

@ExperimentalUnsignedTypes
@Suppress("EXPERIMENTAL_FEATURE_WARNING")
inline class Id(private val v: Int)

Switched it to an

Int

org.aregevdev.kotlinstuff.Id@2503dbd3
Int

Still no change

Whats happening here?

Its something odd with numerical values

@ExperimentalUnsignedTypes
fun main(args: Array<String>) {
    val x = MyString(Wrapper(1))
    println(x)
}

inline class Wrapper(private val v: Int)

inline class MyString(private val v: Wrapper)

org.aregevdev.kotlinstuff.MyString@2503dbd3

With strings it works as expected

Doesn't it just always print the wrapper type? What's the difference in behaviour around strings?

It also crashes when trying to print x.toString()

Haha that's definitely a bug then.

What about avoiding extra allocation by using Collections.addAll on JVM?

That might cause multiple internal expansions

...it makes sense to make

ArrayList<T>.addAll

overload with

ensureCapacity

then.

Wasn't sure if this fit more in here or in #general