JarCastingScalaNullSafe
The purpose of this macro is to provide a quick, easy, readable/writable, and efficient way to make code null-safe in scala.
Quick comparison of null-safe implementations:
| Implementation | Null-safe | Readable & Writable | Efficient |
|---|---|---|---|
| |
|
|
|
| Normal access | |
|
|
| Explicit null-checks | |
|
|
| Option flatMap | |
|
|
| For loop flatMap | |
|
|
| Null-safe navigator | |
|
|
| Try-catch NPE | |
|
|
| Monocle Optional (lenses) | |
|
|
| thoughtworks NullSafe DSL | |
|
|
Key:
How to use
Add the dependency:
libraryDependencies += "com.ryanstull" %% "scalanullsafe" % "1.2.5"
Example use:
import com.ryanstull.nullsafe._
case class A(b: B)
case class B(c: C)
case class C(d: D)
case class D(e: E)
case class E(s: String)
val a = A(B(C(null)))
?(a.b.c.d.e.s) //No NPE! Just returns null
val a2 = A(B(C(D(E("Hello")))))
?(a2.b.c.d.e.s) //Returns "Hello"
There's also a variant that returns an Option[A] when provided an expression of type A, and another that just checks if a property is defined.
opt(a.b.c.d.e.s) //Returns None
notNull(a.b.c.d.e.s) //Returns false
opt(a2.b.c.d.e.s) //Returns Some("Hello")
notNull(a2.b.c.d.e.s) //Returns true
How it works
? macro
The macro works by translating an expression, inserting null-checks before each intermediate result is used, turning ?(a.b.c), for example, into
if(a != null){
val b = a.b
if(b != null){
b.c
} else null
} else null
Or for a longer example, translating ?(a.b.c.d.e.s) into:
if(a != null){
val b = a.b
if(b != null){
val c = b.c
if(c != null){
val d = c.d
if(d != null){
val e = d.e
if(e != null){
e.s
} else null
} else null
} else null
} else null
} else null
opt macro
The opt macro is very similar, translating opt(a.b.c) into:
if(a != null){
val b = a.b
if(b != null){
Option(b.c)
} else None
} else None
notNull macro
And the notNull macro, translating notNull(a.b.c) into:
if(a != null){
val b = a.b
if(b != null){
b.c != null
} else false
} else false
Safe translation
All of the above work for method invocation as well as property access, and the two can be intermixed. For example:
?(someObj.methodA().field1.twoArgMethod("test",1).otherField)
will be translated properly.
Also the macro will make the arguments to method and function calls null-safe as well:
?(a.b.c.method(d.e.f))
So you don't have to worry if d or e would be null.
Custom default for ?
For the ? macro, you can also provide a custom default instead of null, by passing it in as the second parameter. For example
case class Person(name: String)
val person: Person = null
assert(?(person.name,"") == "")
?? macro
There's also a ?? (null coalesce operator) which is used to select the first non-null value from a var-args list of expressions.
case class Person(name: String)
val person = Person(null)
assert(??(person.name)("Bob") == "Bob")
val person2: Person = null
val person3 = Person("Sally")
assert(??(person.name,person2.name,person3.name)("No name") == "Sally")
The null-safe coalesce operator also rewrites each arg so that it's null safe. So you can pass in a.b.c as an expression without worrying if a or b are null. To be more explicit, the ?? macro would translate ??(a.b.c,a2.b.c)(default) into
{
val v1 = if(a != null){
val b = a.b
if(b != null){
val c = b.c
if(c != null){
c
} else null
} else null
} else null
if(v1 != null) v1
else {
val v2 = if(a2 != null){
val b = a2.b
if(b != null){
val c = b.c
if(c != null){
c
} else null
} else null
} else null
if (v2 != null) v2
else default
}
}
Compared to the ? macro in the case of a single arg, the ?? macro check that that entire expression is not null. Whereas the ? macro would just check that the preceding elements (e.g. a and b in a.b.c) aren't null before returning the default value.
Efficient null-checks
The macro is also smart about what it checks for null, so anything that is <: AnyVal will not be checked for null. For example
case class A(b: B)
case class B(c: C)
case class C(s: String)
?(a.b.c.s.asInstanceOf[String].charAt(2).*(2).toString.getBytes.hashCode())
Would be translated to:
if (a != null)
{
val b = a.b;
if (b != null)
{
val c = b.c;
if (c != null)
{
val s = c.s;
if (s != null)
{
val s2 = s.asInstanceOf[String].charAt(2).$times(2).toString();
if (s2 != null)
{
val bytes = s2.getBytes();
if (bytes != null)
bytes.hashCode()
else
null
}
else
null
}
else
null
}
else
null
}
else
null
}
else
null
Performance
Here's the result of running the included jmh benchmarks:
[info] Benchmark Mode Cnt Score Error Units
[info] Benchmarks.fastButUnsafe thrpt 20 230.157 ± 0.572 ops/us
[info] Benchmarks.ScalaNullSafeAbsent thrpt 20 428.124 ± 1.625 ops/us
[info] Benchmarks.ScalaNullSafePresent thrpt 20 232.066 ± 0.575 ops/us
[info] Benchmarks.explicitSafeAbsent thrpt 20 429.090 ± 0.842 ops/us
[info] Benchmarks.explicitSafePresent thrpt 20 231.400 ± 0.660 ops/us
[info] Benchmarks.optionSafeAbsent thrpt 20 139.369 ± 0.272 ops/us
[info] Benchmarks.optionSafePresent thrpt 20 129.394 ± 0.102 ops/us
[info] Benchmarks.loopSafeAbsent thrpt 20 114.330 ± 0.113 ops/us
[info] Benchmarks.loopSafePresent thrpt 20 59.513 ± 0.097 ops/us
[info] Benchmarks.nullSafeNavigatorAbsent thrpt 20 274.222 ± 0.441 ops/us
[info] Benchmarks.nullSafeNavigatorPresent thrpt 20 181.356 ± 1.538 ops/us
[info] Benchmarks.tryCatchSafeAbsent thrpt 20 254.158 ± 0.686 ops/us
[info] Benchmarks.tryCatchSafePresent thrpt 20 230.081 ± 0.659 ops/us
[info] Benchmarks.monocleOptionalAbsent thrpt 20 77.755 ± 0.800 ops/us
[info] Benchmarks.monocleOptionalPresent thrpt 20 36.446 ± 0.506 ops/us
[info] Benchmarks.nullSafeDslAbsent thrpt 30 228.660 ± 0.475 ops/us
[info] Benchmarks.nullSafeDslPresent thrpt 30 119.723 ± 0.506 ops/us
[success] Total time: 3909 s, completed Feb 24, 2019 3:03:02 PM
You can find the source code for the JMH benchmarks here. If you want to run the benchmarks yourself, just run sbt bench, or sbt quick-bench for a shorter run.
These benchmarks compare all of the known ways (or at least the ways that I know of) to handle null-safety in scala. It demonstrates that the explicit null-safety is the highest performing and that the 'ScalaNullSafe' macro has equivalent performance.
Notes
-
Using the
?macro on an expression whose type is<: AnyVal, will result in returning the corresponding java wrapper type. For example?(a.getInt)will returnjava.lang.Integerinstead ofIntbecause the return type for this macro must be nullable. The conversions are the default ones defined inscala.Predef -
If you're having trouble with resolving the correct method when using the
?macro with a default arg, try explicitly specifying the type of the default