Support Nullable{Union{}} with operators

Nullable{Union{}} is always null so we can return null immediately
if one of the arguments is of that type. For unary operators, return
Nullabl(). For binary operators, return Nullable{S}() with S the element
type of the other argument, which carries more information.

src/operators.jl

@@ -71,6 +71,7 @@ for op in (:+, :-, :!, :~, :abs, :abs2, :sqrt, :cbrt)
                            Nullable{R}($op(x.value))
             end
         end
+        $op(x::Nullable{Union{}}) = Nullable()
     end
 end
 
@@ -122,5 +123,8 @@ for op in (:+, :-, :*, :/, :%, :÷, :&, :|, :^, :<<, :>>, :(>>>),
                                         Nullable{R}($op(x.value, y.value))
             end
         end
+        $op(x::Nullable{Union{}}, y::Nullable{Union{}}) = Nullable()
+        $op{S}(x::Nullable{Union{}}, y::Nullable{S}) = Nullable{S}()
+        $op{S}(x::Nullable{S}, y::Nullable{Union{}}) = Nullable{S}()
     end
 end

test/operators.jl

@@ -78,7 +78,7 @@ module TestOperators
         v1 = one(T)
         v2 = T <: Union{BigInt, BigFloat} ? T(rand(Int128)) : rand(T)
 
-        v2 > 5 && (v2 = T(5)) # Work around issue #16989
+        abs(v2) > 5 && (v2 = T(5)) # Work around JuliaLang/julia#16989
 
         # safe unary operators
         for op in (+, -, ~, abs, abs2, cbrt)
@@ -99,6 +99,9 @@ module TestOperators
             @test isa(x, Nullable{R}) && isnull(x)
             x = op(Nullable{R}())
             @test isa(x, Nullable{R}) && isnull(x)
+
+            x = op(Nullable())
+            @test isa(x, Nullable{Union{}}) && isnull(x)
         end
 
         # unsafe unary operators
@@ -120,6 +123,9 @@ module TestOperators
         x = sqrt(Nullable{R}())
         @test isa(x, Nullable{R}) && isnull(x)
 
+        x = sqrt(Nullable())
+        @test isa(x, Nullable{Union{}}) && isnull(x)
+
         for u in (u0, u1, u2), v in (v0, v1, v2)
             # safe binary operators
             for op in (+, -, *, /, &, |, >>, <<, >>>,
@@ -143,6 +149,13 @@ module TestOperators
                 @test isa(x, Nullable{R}) && isnull(x)
                 x = op(Nullable(u, true), Nullable(v))
                 @test isa(x, Nullable{R}) && isnull(x)
+
+                x = op(Nullable(u, true), Nullable())
+                @test isa(x, Nullable{S}) && isnull(x)
+                x = op(Nullable(), Nullable(u, true))
+                @test isa(x, Nullable{S}) && isnull(x)
+                x = op(Nullable(), Nullable())
+                @test isa(x, Nullable{Union{}}) && isnull(x)
             end
 
             # unsafe binary operators
@@ -159,6 +172,13 @@ module TestOperators
             x = Nullable(u, true)^Nullable(-abs(v), false)
             @test isnull(x) && eltype(x) === R
 
+            x = Nullable(u, true)^Nullable()
+            @test isa(x, Nullable{S}) && isnull(x)
+            x = Nullable()^Nullable(u, true)
+            @test isa(x, Nullable{S}) && isnull(x)
+            x = Nullable()^Nullable()
+            @test isa(x, Nullable{Union{}}) && isnull(x)
+
             # ÷ and %
             for op in (÷, %)
                 if S <: Integer && T <: Integer && v == 0
@@ -173,6 +193,13 @@ module TestOperators
                 @test isnull(x) && eltype(x) === R
                 x = op(Nullable(u, true), Nullable(v, false))
                 @test isnull(x) && eltype(x) === R
+
+                x = op(Nullable(u, true), Nullable())
+                @test isa(x, Nullable{S}) && isnull(x)
+                x = op(Nullable(), Nullable(u, true))
+                @test isa(x, Nullable{S}) && isnull(x)
+                x = op(Nullable(), Nullable())
+                @test isa(x, Nullable{Union{}}) && isnull(x)
             end
         end
     end