@ryotamurohoshi well,

Kotlin has null safety

doesn't mean there are no `null`s anymore. IMHO it means that by mistake you won't get NPEs, You need something like

!!

to produce NPEs

@ryotamurohoshi Not following your point. Pure Kotlin code is NPE safe unless you use

!!

. That's a very important property that very few languages offer today.

@Andreas Sinz @cedric When I write Kotlin, usually I need to use Kotlin with Java. How do you think platform type? We know that there is Platform Type and it becomes reason of NullPointerException or IllegalStateException.

And I know that there are good features to manage null in Kotlin. But I want to know that there is definition for Null safety. I am sorry my not Good English skill and question.

codebases that don't include any unannotated Java, or use dependencies with unannotated Java, are NPE-safe unless you use

!!

. In practice, I've never seen a Kotlin codebase that fits these constraints though, which is why I'd love to see a compiler option to treat platform types as nullable types

I know that there are some annotations to Kotlin compiler. nullable or not nullable.

Sorry, my question can be more better.

I want to know definition of null safety.

Like how the compiler does it?

It has a ton of calls to Intrinsics to verify that stuff isn't null, so that the code below is guaranteed to not throw NullPointerExceptions

If it's nullable and you use the null-safe operator, it just starts chaining the calls with if(x != null) between them

And !! would just be chaining the calls as normal, with the chance for an NPE if something is null

Well a lot of the safety comes from static analysis. Runtime checks are only necessary when dealing with platform types

Yeah, above opinion is totally aggree. And I love Kotlin and the features. They are so nice!

By the way, I hava question the words of

Kotlin is null safety language

or

Kotlin has null safety.

Because there is no clearly definition for

null safety

in Kotlin document. There are features description only.

By the way, It is not big problem. Its problem of way of saying. Thank you for your answers.

🙇 👍

Is there way to specify that type parameter is nullable?

class C<T>{
    x: T = null // ERROR: null cannot be assigned to non-null type T
}

aah. got ansewer %)

class C<T>{
    x: T? = null
}

Does anyone know if I can use the Kotlin logo for free in an article I'm writing?

@kevinmost With generics involved it's no longer a matter of one extra character. 1 reply ilya.gorbunov: Can I get an example of how introducing generics makes null handling different?

Java:``` import javax.script.*; import jdk.nashorn.api.scripting.*; import java.util.*; import java.util.function.*; public class scratch_6 { public static void main(String[] args) throws Exception { ScriptEngineManager m = new ScriptEngineManager(); ScriptEngine e = m.getEngineByName("nashorn"); // The following JSObject wraps this list List<Object> l = new ArrayList<>(); l.add("hello"); l.add("world"); l.add(true); l.add(1); JSObject jsObj = new AbstractJSObject() { @Override public Object getMember(String name) { if (name.equals("map")) { // return a functional interface object - nashorn will treat it like // script function! return (Function<JSObject, Object>)callback -> { List<Object> res = new ArrayList<>(); for (Object obj : l) { // call callback on each object and add the result to new list res.add(callback.call(null, obj)); } // return fresh list as result of map (or this could be another wrapper) return res; }; } else { // unknown property return null; } } }; e.put("obj", jsObj); // map each String to it's uppercase and print result of map e.eval("print(obj.map(function(x) '\"'+x.toString()+'\"'))"); } }``` Kotlin:``` package com.jsonlogic import javax.script.* import jdk.nashorn.api.scripting.* import java.util.* import java.util.function.Function fun main(args: Array<String>) { val m = ScriptEngineManager() val e = m.getEngineByName("nashorn") // The following JSObject wraps this list val l = mutableListOf<Any>() l.add("hello") l.add("world") l.add(true) l.add(1) val jsObj = object : AbstractJSObject() { override fun getMember(name: String?): Any? { if (name == "map") { // return a functional interface object - nashorn will treat it like // script function! return { callback: Function<Any?, Any?> -> val res = ArrayList<Any?>() for (obj in l) { // call callback on each object and add the result to new list res.add(callback.apply(obj)) } // return fresh list as result of map (or this could be another wrapper) res } } else { // unknown property return null } } } e.put("obj", jsObj) // map each String to it's uppercase and print result of map e.eval("print(obj.map(function(x) '\"'+x.toString()+'\"'))"); } ```

The Kotlin code throws the error “obj.map is not a function” which seems to indicate that the lambda being returned on line 24 is not recognizable as a scriptable function.

Aha I got it

The callback isn’t a Function, it is a ScriptObjectMirror

how can I make this work?

val list: ObservableList<Calendar> = things.map{    ObservableField(it)}

basically I need to convert a list into an ObservableList

Is this JavaFx?

I found https://stackoverflow.com/a/22192238/615306