Okay, thanks. I guess I’ll stick to calling it Observable_fromNullable then.

@michaelzinn

class Foo {
  companion object
}

fun Foo.Companion.bar() { println("bar") }

fun main(args: Array<String>) {
  Foo.bar()
}

only works for Kotlin classes though

and only if the class already has a companion object

It doesn’t have a companion object, it’s written in Java.

enforced immmutability all the way down

Do you mean an immutable list of mutable objects but the list prevents the objects from being mutated? Is that even possible on the jvm?

@benleggiero commented on @leonardootto’s file https://kotlinlang.slack.com/files/U29NJHBRP/F6QJZ364R/3_starting_questions.kt:

@JvmName

doesn't exist outside the JVM Kotlin compiler

@benleggiero commented on @leonardootto’s file https://kotlinlang.slack.com/files/U29NJHBRP/F6QJZ364R/3_starting_questions.kt: As for a better way to write this:

val Collection<String>.palindromes: List<String>
    get() = map { it.split(" ") } .filter { it.isPalindrome()) }
​
var MutableCollection<String>.palindromes: List<String>
    @JvmName("prop2")
    get() = map { it.split(" ") } .filter { it.isPalindrome()) }
    set(list: List<String>) = addAll(list.palindromes)

Kotlin compiler inserts @Nullable and @NotNull from org.jetbrains.annotations, is it possible to insert also javax.validation.constraints.NotNull ?

@leonardootto commented on @leonardootto’s file https://kotlinlang.slack.com/files/U29NJHBRP/F6QJZ364R/3_starting_questions.kt: Thanks Ben. I try simplify the code only to extension property, This is the reason why i don’t create a more function code. But you are right this is the more simple way.

@User uploaded a file: Untitled

Is there anything that speaks against this to replace redundant constant naming?

@kingsley commented on @arekolek’s file https://kotlinlang.slack.com/files/U6M6DATB5/F6RDDE7KP/foreach.kt: Whatever happened to:

arrayOf(1, 2, 5).forEach(::println)

? 😉

@arekolek commented on @arekolek’s file https://kotlinlang.slack.com/files/U6M6DATB5/F6RDDE7KP/foreach.kt: Basically,

arrayOf

and

listOf

was what I was hoping to avoid 😛

Why?

@karelpeeters commented on @Paul Woitaschek’s file https://kotlinlang.slack.com/files/U0KBF8D7V/F6RGRGVC5/-.kt: That's a delegate, right? The problem with this is that it's not that fast.

@kingsley commented on @arekolek’s file https://kotlinlang.slack.com/files/U6M6DATB5/F6RDDE7KP/foreach.kt: Basically, either methods generate the same bytecode. You get even better performance with specialized primitive arrays like

intArrayOf(1, 2, 3)

which avoids the boxing

@arekolek commented on @arekolek’s file https://kotlinlang.slack.com/files/U6M6DATB5/F6RDDE7KP/foreach.kt: Also, those ints were just an example. Actually I was using totally different objects.

@arekolek commented on @arekolek’s file https://kotlinlang.slack.com/files/U6M6DATB5/F6RDDE7KP/foreach.kt: The question was more about whether it’s possible to type 8 fewer characters to get the same thing

Does that really matter?

Like is this line going to make or break your application

@kingsley commented on @arekolek’s file https://kotlinlang.slack.com/files/U6M6DATB5/F6RDDE7KP/foreach.kt: Ah. Right. Sure you can always use your function and avoid the fewer characters. Personally though, I don’t have any problems with them 🙂

Nope, but if the functionality existed, I’d like to know that.

@krissrex commented on @jelloranger’s file https://kotlinlang.slack.com/files/U6P0EN0DU/F6QJMNTUY/-.txt: Your

compile 'junit:junit:4.12'

should use

testCompile

instead of

compile

. That way, junit is not added to the apk. (This will not fix your problem, just reduce apk size).

Why does the

Sequence

interface exist at all? The only thing it does is return an iterator, so why this step of indirection? It would also be possible to just pass the

Iterator

itself.

it's a lazy Iterable

I don't really understand that, why can't an

Iterable

be lazy?

It's a convention thing.

filter

on an

Iterable

eagerly filters the elements and returns a (filtered)

List

.

filter

on

Sequence

returns a new

Sequence

which lazily filters the elements. Same for

map

,

flatMap

, etc.

I see, thanks!

I guess it makes sense that things like

Collection.filter

eagerly filter indeed.