Empty collections behave that way for

set.all { it.test }

to be equivalent to

!set.any { !it.test }

in all cases. Found more information here: https://en.wikipedia.org/wiki/Vacuous_truth and http://math.stackexchange.com/questions/202452/why-is-predicate-all-as-in-allset-true-if-the-set-is-empty

Hey, I found out that this:

var columns = listOf<MutableList<EventRect>>()
for (eventRect in collisionGroup) {
    val properColumn = columns.firstOrNull { column -> !isEventsCollide(eventRect.event, column[column.size - 1].event) }
    if(properColumn != null) {
        properColumn.add(eventRect)
    } else {
        columns = columns.plusElement(mutableListOf(eventRect))
    }
}

is pretty common pattern. Like groupBy, but being in the group depend on other elements in this group. Like elements that are close enough to themself

I have a class

class EnumStringConverter<E extends Enum> implements Converter<E, String>

which I must provide for this annotation:

public @interface Convert {
    Class<? extends Converter> value();
}

When I do it like this:

@get:Convert(EnumStringConverter::class)

I get:

Error:(95, 19) error: constructor EnumStringConverter in class EnumStringConverter<E> cannot be applied to given types;
required: Class
found: no arguments
reason: actual and formal argument lists differ in length
where E is a type-variable:
E extends Enum declared in class EnumStringConverter

And I don't know how to properly provide the type. Could you help please?

I was trying to apply the mentioned annotation in an interface, not a class. Do you think it was causing the problems?

i’m going to bang those out tonight!

Please, be careful what you wish for. We don't want Kotlin compiler (which is now written mostly in Kotlin and extensively uses Kotlin stdlib) to become slower than it is now, don't we? We actually plan to improve upon its performance.

Lenses if a functional solution to this problem. No, in imperative language you can do better. Just like with collections. How would you modify an an immutable collection efficiently? Imagine something like this:

val list = … // some immutable list here
val updated = list.mutate { 
   add(”…”) // efficiently perform a series of mutating operations
   add(”…”)
}

where

mutate

is a helper function that “opens” and efficiently rebuilds immutable structure:

fun <T> List<T>.mutate(block: MutableList<T>.() -> Unit): List<T>

You should have a similar API for immutable data classes:

val person = Person(first = “John”, last = “Smith”) // immutable person object with lots of props
val updated = person.mutate { 
   age = 31
   occuptation = “Manager”
}

It is considerably more readable than the solution with lenses.

There is not much difference in flexibility. It is just that updating nested structures with lenses becomes an exercise in following chains of maps. Moreover, if you are using lenses in Haskel-like (pure) language, then you get a benefit of do-notation and advanced optimizations over sequences of lazy operations. If we were to naively rewrite Monad-style lenses approach from Haskell to Kotlin, it would be quite verbose, because in Kotlin you’ll have to do

::

to refer to functions and properties and you don’t have a do notation, and it would have been very inefficient, because you don’t have an advantage of purity to optimize back-to-back updates into one. However, Kotlin is an imperative language, so you should not be needing a do notation to start with, and you can directly express a sequence of updates to the the same object, without the need to rely on the smart optimizer to make it efficient.

@elizarov the

copy

function is effectively a persister (read: local factory) function to make data classes persistent isn't it?

data class Thingy(val x: Double, val y: Int)

val first = Thingy(1.0, 42)
val second = first.copy(x = 2.0)

you dont get any sharing but you do get persistence.

do they not already?

is anyone else getting spurious compiler errors when using

internal typealias

?

Error:(107, 91) Cannot access 'ValidationErrors': it is internal in ‘[module]’

usages are all also in

[module]

sure, just make sure your collection is actually mutable

Did I miss something or there is no function for mapping array to array? (there is only array to list)

@mg6maciej https://kotlinlang.org/docs/reference/whatsnew11.html#array-like-list-instantiation-functions

@mg6maciej

val newList = list.minusIndex(i)

I wonder if Kotlin's persistent collections have these missing APIs.

Is there a function that uses

IndexedValue

or do I just call it

.mapIndexed(::IndexedValue)

?

Beware that

subList

is a view. If original list changes, then sublist also changes.

@mg6maciej AFAIK, an internal typealias in a public signature should be replaced with its public substitution, but that feature may be not working.

@orangy The following code throws, is this the expected behavior? It looks like

copyRecursively

is changing the target from a directory to a file:

fun main(args: Array<String>) {
    val from = File("/tmp/foo").apply { writeText("I'm a file") }
    val to = File("/tmp/to").apply {
        deleteRecursively()
        mkdirs()
    }
    from.copyRecursively(to, overwrite = true)
    if (! to.isDirectory) {
        throw AssertionError("Should be a directory")
    }
}

Some cool things such as

Quadruple<A, B, C, D>

,

Option<T>

,

Either<L, R>

,

fun Quadruple<*, *, *, *>.sendIntoOuterSpace()

and many others could be implemented... outside of stdlib. 🙃 @benleggiero why do you think Triple should have all that Pair has? For example, I ignore existence of both in most cases 😒imple_smile: @mbstavola can you show any use-cases? I just wonder why do you need this.

almost never uses pair, it's usually much better to make a descriptive class

How would you call a function that returns all possible sublists of a list? e.g. for

listOf(A, B)

=>

listOf(emptyList(), listOf(A), listOf(B), listOf(A, B))

IMHO 1)

MapWithDefault

2)

MapWithDefault

3)

MapWithDefault

with default from second

Do you think it might be useful to have something like

fun Throwable.stackTrace(): String

in stdlib? (e.g. https://github.com/JetBrains/kotlin/blob/0d1c803f71667ded0b313491d9e0c50511d63cbf/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/incremental/jvmUtils.kt#L6-L6)

how can I make from

List<Pair<String, Double?>>

Map<String,Double>

pairs.filter { it.second != null }.toMap()

returns

Map<String, Double?>

My

MutableLazy

implementation is here: https://gist.github.com/LouisCAD/9b4ef46c12f1f6fe9b45658a8eff194c

Shouldn't

public operator fun <T> Iterable<T>.minus(element: T): List<T>

be defined with element as nullable?

public operator fun <T> Iterable<T>.minus(element: T?): List<T>

I.e. if you call

listOf<String>(...) - null as String?

it would just return the same

List<String>

and not

List<String?>

as it currently does.

Why aren't plus/minus operators defined on

Array<T>

?