It also has no option to directly inline an interpolated variable

@Kirill Zhukov has left the channel

@sreich: you can quick-fix string concatenation into a template, and then quick-fix the template into a multi line string (aka raw string literal)

One thing I'd is a quick fix to go from a raw string literal to a nicely indented multiline string with a margin and a call to trimMargin

I am trying to migrating to Gradle

if I plan to use gradle modules, shall I use also a gradle project?

I just enabled auto-run for my tests

I never got them to run automatically 😞

@User uploaded a file: and commented: Please can we have the

Kind

dropdown default to the last kind selected? For people who create many Kotlin classes and who don't like to click this thing every time, this might be helpful.

@oluwasayo workaround without clicking may be to press up/down on keyboard. It works for

Kind

even if

Name

is focused

Is there a way to enable similar SQL syntax highlighting for a custom method? Maybe an annotation for a parameter. http://take.ms/raofj

@dstarcev you can use inject language

@christophsturm thanks👍

Hello everyone. Just started paying around with Kotlin Koans. There is one thing that bugs me though: Code completion for SAM. I i write something like:

list.asSequence()
    .filter{}

it auto completes with curly braces after filter. However I feel that many times I want to use Function references. Which means I need to delete the curly braces and replace them with parentheses. Is there a way to change the completion to not generate braces or parentheses?

Also is there a way to not write curly braces if I’m already using the arrow operator?

For example if I have a function that takes more than one lambdas: foo.bar( a-> a.asSequence[…], b -> if[…])

https://kotlinlang.slack.com/archives/intellij/p1483969447000151 Good point, you can open an issue on http://kotl.in/issue

as for the other question, the rules are: if the last or single argument is a lambda you can put it outside the parans so

filter({})

,

filter() {}

and

filter {}

are the same thing. the last version is the preferred one. this also works if you have multiple lambda arguments, but only for the last one. so you can only do

foo({}) {}

but not

foo {} {}

not sure if this was also part of the question, but if your lambda has 0 or 1 parameters, you can leave you the arrow so

foo { -> }

and

foo {}

is the same as well as

foo { a -> a }

and

foo { it }

also see #getting-started and http://kotlinlang.org/docs/reference/lambdas.html @alex0ptr

oh and you should be careful when using the term "SAM". in kotlin it refers to java interfaces with a single method that can be implemented by a lambda. in the case of

() -> T

and friends, the correct term is "function types"

@kirillrakhman Thanks, I’ll open one. You misunderstood my second question though (which is my fault), but I just realized it was flawed anyways 🙂. Also thank you for clarifying SAM!

@User uploaded a file: and commented:

crop(top = 0, left=200, bottom=400, right=600)

would make this statement more readable But since it's a java function, named arguments are not allowed. Could the IDE displays them nonetheless as it does it in java when the option

Inline parameters for litteral call arguments

is set?

yes, it's planned to support this option

I want to be aware of all usages of platform types. I got a project with NPE issues because of misusing platform types (

?

are lost for unknown reason, maybe during migrations to kotlin or just Java code returns

null

too unexpectedly) I don't understand how kotlin plugin warns about that - I've found only

"Function or property has platform type"

inspection, but i have no warnings at all for this code: Java:

public class TestClass {

    private Integer i1;
    private Integer i2;

    public TestClass(Integer i1, Integer i2) {
        this.i1 = i1;
        this.i2 = i2;
    }
}

Kotlin

class TestClient {
    val x: Int? = null
    
    fun foo() {
        val java = TestClass(x, x)
    }
}

this inspection warns you when you call a java method and return the result without specifying nullability, so it's the reverse of your problem

in your case, the kotlin code doesn't generate a warning or error because it doesn't know whether

TestClass

can handle nulls. If you annotate the parameters of the java class with

@NotNull

then a warning/error will appear on the kotlin side

@kirillrakhman Totally missing `@NonNull`s are the headache platform types are to care of, because I can't inspect all the java code for

@NonNull

(And I shouldn't really do it because of OCP). I guess it'd be enough to look through only the places, where kotlin uses the java code with platform types and remove those NPE-generating platform types where needed. @yole I don't like platform types😢 Hear my pain😊

Is there a way to find every platform type usage in code?