Why is slice a possible language future feature?

salomonbrys 2017-04-07 08:51:24 UTC #1

In the language future survey, the item 8 is "Slices for lists and arrays".

I don't really understand why would the language need enhancement while this would really easilly done by the stdlib:

operator fun <T> List<T>.get(r: IntRange) = subList(r.start, r.endInclusive + 1)
operator fun <T> List<T>.get(r: IntRange, step: Int) = subList(r.start, r.endInclusive + 1).filterIndexed { index, _ -> index % step == 0 }

fun main(args: Array<String>) {
    val list = listOf(0, 1, 2, 3, 4, 5)
    println(list[1..4])
    println(list[1 until 4])
    println(list[1..4, 2])
}

What would be the benefit of adding a new language syntax?

fvasco 2017-04-07 11:00:57 UTC #2

Fully agree.

Why not?

println(list[1..4 step 2])

fvasco 2017-04-08 06:19:49 UTC #4

Kotlin 1.0:

val list = listOf(0, 1, 2, 3, 4, 5)
println(list.slice(1 until 4 step 2))

yole 2017-04-08 10:53:41 UTC #5

Array slices are extremely common in data manipulation code (see numpy/scipy in the Python world), so it may make sense to make it as easy as possible to use them in Kotlin as well.

fvasco 2017-04-08 18:12:01 UTC #6

This looks really like the ternary operator debate.

umar.uzdenov.krch 2017-04-09 11:41:15 UTC #7

I created a little bunch of extensions for slicing compatible with 1.0
Obviously it doesn't fit for all use cases but simple enough for me to use in little pet projects

gist.github.com

https://gist.github.com/lameroid/b7164587249c146e126704c67464e41a#file-list_slicing_extension-kt

list_slicing_extension.kt

fun lsxUsage() {
    val list = listOf(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

    println(list[1..3])          // [3, 5, 7]
    println(list[1 til 3])       // [3, 5]
    println(list[4..1])          // [11, 7, 5, 3]
    println(list[4 til 1])       // [11, 7, 5]
    println(list[2..-1])         // [5, 7, 11, 13, 17, 19, 23, 29]
    println(list[2 til -1])      // [5, 7, 11, 13, 17, 19, 23]
    println(list[3..0 by 1])     // [7, 5, 3, 2]

This file has been truncated. show original

salomonbrys 2017-04-09 20:31:52 UTC #8

@yole I do not question the need for the feature, which is obvious.

I question the need for a new language syntax!

yole 2017-04-09 21:39:46 UTC #9

The key words in my reply are "as easy as possible". In many cases, explicit syntax makes a feature easier to use than the application of a library feature.

fvasco 2017-04-10 06:54:13 UTC #10

umar.uzdenov.krch 2017-04-10 09:02:16 UTC #11

Yeah, but why our code must be verbose when it can be concise?
Also, Kotlin is powerful enough to create another DSL for slicing, something like this:

gist.github.com

https://gist.github.com/lameroid/f627801fae6b80c7f14e6094cb84a1e5#file-list_slicing_dsl-kt

list_slicing_dsl.kt

val list = listOf(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

list[1, 3]    // [3, 5, 7]
list[4, 1]    // [11, 7, 5, 3]
list[2, -1]   // [5, 7, 11, 13, 17, 19, 23, 29]
list[3, 0, 1]  // [7, 5, 3, 2]
list[-1, 1, 2] // [29, 19, 13, 7, 3]

or this:

gist.github.com

https://gist.github.com/lameroid/5efda0a70e4d482041f59b7d208cd27e#file-list_slicing_dsl_example-kt

list_slicing_dsl_example.kt

val list = listOf(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

list[!5]      // [13, 17, 19, 23, 29]
list[!1/3]    // [3, 5, 7]
list[!4/1]    // [11, 7, 5, 3]
list[!2/-1]   // [5, 7, 11, 13, 17, 19, 23, 29]
list[!3/0/1]  // [7, 5, 3, 2]
list[!-1/1/2] // [29, 19, 13, 7, 3]

And yes, it can be unclear at first, but simple and special enough to become familiar after 5 minutes of coding.

umar.uzdenov.krch 2017-04-10 09:11:39 UTC #12

Yes, special built-in syntax for common feature is good, but adding ad-hoc syntax for list and array slicing only seems as overkill
For example: You can provide a new operators:

gist.github.com

https://gist.github.com/lameroid/763568e4dd00cb7a4e1ccf02b804e056#file-list_slicing_operator_example-kt

list_slicing_operator_example.kt

operator fun <T, A, B, C> T.getSlice(first: A, last: B, step: C)
operator fun <T, A, B, C, S> T.setSlice(first: A, last: B, step: C, value: S)
and we can use them:
operator fun <T> List<T>.getSlice(first: Int = 0, last: Int = size - 1, step: Int = 1)
list[first:]
list[first:last]
list[first:last:step]
list[:last]
list[:last:step]
list[first: :step]

This file has been truncated. show original

camabeh 2017-04-16 19:18:28 UTC #13

+1 for new operators. It could open new possibilities/use cases.

fvasco 2017-04-18 05:19:36 UTC #14

Why don't show those?

file.exist() : { file.delete() } ?: throw FileNotFoundException()

val list = item1 : item2 : item3

However I am curious to know about new operator, something like:

operator fun Int.colon(other: Int) = this until other
operator fun IntProgression.colon(other: Int) = this step other