kotlinlang #stdlib

Channels

portugal

romania

argentina

stayhungrystayfoolish

skia-wasm-interop-temp

java-to-kotlin-refactoring

event21-community-content

refactoring-to-kotlin

kotlin-multiplatform-contest

tricity-kotlin-user-group

cincinnati-user-group

prozis-android-backup

russian-kotlinasfirst

juul-libraries

lanark

wimix_sentry

androidgithubprojects

swagger-gradle-codegen

competitive-programming

navigation-architecture-component

myndocs-oauth2-server

practical-functional-programming

hyderabad

kotlinultimatechallenge

jvm-ir-backend-feedback

uhe

06/29/2017, 12:03 PM

which would mean the "elvis-else"

?:

is also executed

menegatti

06/29/2017, 1:18 PM

good point, I forgot to consider that scenario

mg6maciej

06/29/2017, 7:27 PM

22 times

😂 1

nkiesel

06/30/2017, 1:11 AM

what's the best way to map a list into a potentially longer list? Something like

Copy code

val longer = mutableListOf<Int>()
listOf(2,3,4).forEach { longer.add(it); if (it % 2 == 0) longer.add(-it) }

nkiesel

06/30/2017, 1:17 AM

best I have so far is

val longer = mutableListOf<Int>().apply { listOf(2,3,4).forEach { add(it); if (it % 2 == 0) add(-it) } }.toList()

06/30/2017, 1:32 AM

flatMap

nkiesel

06/30/2017, 1:43 AM

tried that but requires to create inner mutable lists for every outer element. Not sure that is really better.

nkiesel

06/30/2017, 1:46 AM

listOf(2,3,4).flatMap { val l = mutableListOf(it); if (it % 2 == 0) l.add(-it); l }

gildor

06/30/2017, 2:00 AM

Maybe something like:

Copy code

listOf(2, 3, 4).flatMap { item ->
        List(if (item % 2 == 0) 2 else 1) {
            if (it == 0) item else -item
        }
}

not sure that it is readable enough, but no mutable states

nkiesel

06/30/2017, 2:03 AM

yeah. actual code is more complicated though: multiple conditions that determine if additional items need to be added. The

flatMap

approach at least makes it clear that the lambda constructs a list of items for every item, so that is what I chose so far.

ilya.gorbunov

06/30/2017, 2:14 AM

We're considering to introduce something like combination of

flatMap { buildSequence { }}

, say

flatBuild

, so that one could yield several values from lambda:

Copy code

listOf(2, 3, 4).flatBuild { 
    yield(it)
    if (it % 2 == 0) yield(-it)
}

👍 4

nkiesel

06/30/2017, 2:14 AM

that would be nice. I had multiple places where I would have used that

nkiesel

06/30/2017, 2:16 AM

seems unbalanced that it's so easy to drop elements using

filter

and so hard to expand elements

gildor

06/30/2017, 2:25 AM

flatMap { buildSequence { }}

actually looks nice for this case and works, you just need coroutines for that:

Copy code

listOf(2, 3, 4).flatMap { buildSequence {
        yield(it)
        if (it % 2 == 0) yield(-it)
}.toList() }

gildor

06/30/2017, 2:26 AM

or:

Copy code

sequenceOf(2, 3, 4).flatMap { buildSequence {
        yield(it)
        if (it % 2 == 0) yield(-it)
}}.toList()

mikehearn

07/03/2017, 3:08 PM

@mikehearn has left the channel

voddan

07/03/2017, 3:45 PM

I think it is awesome that KEEP-11 is finally being implemented in 1.2, which brings us the long awaited

chunked

and

windowed

functions. While most of the proposal looks very solid, the

pairwise

is a bit controversial. It has two major problems: 1) The naming is ambiguous since the word "pairwise" may generally be used for 3 different things. More other, the proposal uses one of its rarer meanings. 2) It is unclear why there is a need for a separate function which does the work of

windowed(size = 2, step = 1)

. In addition, if a change to make

step = 1

the default is adopted, that alternative changes to a short

windowed(2)

, which makes

pairwise

even less competitive. In short, adding

pairwise

does not seem to add a lot of value while creating an ambiguity. I believe we should exclude

pairwise

at least from 1.2 to see if there is as mach demand as expected. Here is the KEEP-11 discussion https://github.com/Kotlin/KEEP/issues/11

ilya.gorbunov

07/03/2017, 3:52 PM

pairwise { a, b -> }

has an advantage over

windowed(2) { window -> }

that it doesn't allocate a list to represent a window. Also being a simplified case of

windowed

it has an implementation more suitable to be inlined. Therefore

pairwise

is inline, while

windowed

is not.

voddan

07/03/2017, 3:59 PM

Why there is no specialized version of

chunked(2)

then? They seem to be very symmetrical

ilya.gorbunov

07/03/2017, 4:05 PM

We couldn't find enough use cases for such specialized

chunked

. Can you?

voddan

07/03/2017, 4:10 PM

I am trying to understand the naming. If we add

pairwise

for optimization purposes, then it would make sense to call it

windowed2(step)

as an indication of that. That would make even more sense with a

chunked2()

function, but if you say there are no use cases, I don't insist.

voddan

07/03/2017, 4:12 PM

Can you explain why "pairwise" was chosen over "windowed2" and other contenders?

ilya.gorbunov

07/03/2017, 4:16 PM

It's the same reason we have

Pair

instead of

Tuple2

voddan

07/03/2017, 4:23 PM

I just thought about naming it

pairs()

. It shouldn't clash with anything, and it does not suggest N*N combinations. Altho it still does not make it clear if it produces overlapping pairs or not

👍 1

07/03/2017, 4:48 PM

is there anything for shifting arrays in-place? something that would emit a

System.arraycopy

call on the JVM with the same source and destination instance?

07/03/2017, 4:49 PM

in JS it would do a slice and concat or something i guess

07/03/2017, 4:50 PM

there doesn't even seem to be anything that lets me do the shift into a new array

ilya.gorbunov

07/03/2017, 4:53 PM

@jw, exposing arraycopy in some form is planned: https://youtrack.jetbrains.com/issue/KT-17392

👍 4

07/03/2017, 4:54 PM

shift into a new array i guess could use the lambda param on initializer

enleur

07/07/2017, 7:25 AM

I can’t find window-sliding implementation in kotlin sources https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib, Could someone point me to it?