Implement lifting infrastructure

Author: davidagold

base/exports.jl

@@ -1326,6 +1326,7 @@ export
 # nullable types
     isnull,
     unsafe_get,
+    Lifted,
 
 # Macros
     # parser internal

base/nullable.jl

@@ -217,3 +217,127 @@ function hash(x::Nullable, h::UInt)
         return hash(x.value, h + nullablehash_seed)
     end
 end
+
+"""
+    Lifted{F}
+
+A type used to represent the lifted version of a function `f::F`.
+
+Calling an `_f::Lifted{F}` on arguments `xs...` lowers to
+`lift(_f.f, U, xs...)`, where the return type parameter `U` is chosen with the
+help of type inference.
+"""
+immutable Lifted{F}
+    f::F
+    cache::Dict{Tuple{Vararg{DataType}}, DataType}
+
+    (::Type{Lifted}){F}(f::F) = new{F}(
+        f, Dict{Tuple{Vararg{DataType}}, DataType}()
+    )
+end
+
+function (_f::Lifted{F}){F}(xs...)
+    f, cache = _f.f, _f.cache
+    signature = map(eltype, xs)
+    U = Base.@get!(
+        cache,
+        signature,
+        Core.Inference.return_type(f, Tuple{signature...})
+    )
+    return lift(f, U, xs...)
+end
+
+"""
+    lift(f::F)::Lifted{F}
+
+Return a lifted version of `f`.
+"""
+lift(f) = Lifted(f)
+
+"""
+    lift(f, U, xs...)
+
+Return an empty `Nullable{U}` if any of the `xs` is null; otherwise, return the
+(`Nullable`-wrapped) value of `f` applied to the values of the `xs`.
+
+NOTE: There are two exceptions to the above: `lift(|, Bool, x, y)` and
+`lift(&, Bool, x, y)`. These methods both follow three-valued logic semantics.
+"""
+function lift(f, U::DataType, x)
+    if isnull(x)
+        return Nullable{U}()
+    else
+        return Nullable{U}(f(unsafe_get(x)))
+    end
+end
+
+function lift(f, U::DataType, x1, x2)
+    if isnull(x1) | isnull(x2)
+        return Nullable{U}()
+    else
+        return Nullable{U}(f(unsafe_get(x1), unsafe_get(x2)))
+    end
+end
+
+function lift(f, U::DataType, xs...)
+    if mapreduce(isnull, |, false, xs)
+        return Nullable{U}()
+    else
+        return Nullable{U}(f(map(unsafe_get, xs)...))
+    end
+end
+
+# Three-valued logic
+
+(::Lifted{&})(x::Union{Bool, Nullable{Bool}}, y::Union{Bool, Nullable{Bool}}) =
+    lift(&, Bool, x, y)
+(::Lifted{|})(x::Union{Bool, Nullable{Bool}}, y::Union{Bool, Nullable{Bool}}) =
+    lift(|, Bool, x, y)
+
+function lift(f::typeof(&), ::Type{Bool}, x, y)::Nullable{Bool}
+    return ifelse(
+        isnull(x),
+        ifelse(
+            isnull(y),
+            Nullable{Bool}(),
+            ifelse(
+                unsafe_get(y),
+                Nullable{Bool}(),
+                Nullable(false)
+            )
+        ),
+        ifelse(
+            isnull(y),
+            ifelse(
+                unsafe_get(x),
+                Nullable{Bool}(),
+                Nullable(false)
+            ),
+            Nullable(unsafe_get(x) & unsafe_get(y))
+        )
+    )
+end
+
+function lift(f::typeof(|), ::Type{Bool}, x, y)::Nullable{Bool}
+    return ifelse(
+        isnull(x),
+        ifelse(
+            isnull(y),
+            Nullable{Bool}(),
+            ifelse(
+                unsafe_get(y),
+                Nullable(true),
+                Nullable{Bool}()
+            )
+        ),
+        ifelse(
+            isnull(y),
+            ifelse(
+                unsafe_get(x),
+                Nullable(true),
+                Nullable{Bool}()
+            ),
+            Nullable(unsafe_get(x) | unsafe_get(y))
+        )
+    )
+end

test/nullable.jl

@@ -387,3 +387,72 @@ end
 
 # issue #11675
 @test repr(Nullable()) == "Nullable{Union{}}()"
+
+# lifting
+
+f(x::Number) = 5 * x
+f(x::Number, y::Number) = x + y
+f(x::Number, y::Number, z::Number) = x + y * z
+_f = lift(f)
+
+for T in setdiff(types, [Bool])
+    a = one(T)
+    x = Nullable{T}(a)
+    y = Nullable{T}()
+
+    U1 = Core.Inference.return_type(f, Tuple{T})
+    @test isequal(_f(x), Nullable(f(a)))
+    @test isequal(_f(y), Nullable{U1}())
+
+    U2 = Core.Inference.return_type(f, Tuple{T, T})
+    @test isequal(_f(x, x), Nullable(f(a, a)))
+    @test isequal(_f(x, y), Nullable{U2}())
+
+    U3 = Core.Inference.return_type(f, Tuple{T, T, T})
+    @test isequal(_f(x, x, x), Nullable(f(a, a, a)))
+    @test isequal(_f(x, y, x), Nullable{U3}())
+end
+
+# three-valued logic
+
+# & truth table
+v1 = lift(&, Bool, Nullable(true), Nullable(true))
+v2 = lift(&, Bool, Nullable(true), Nullable(false))
+v3 = lift(&, Bool, Nullable(true), Nullable{Bool}())
+v4 = lift(&, Bool, Nullable(false), Nullable(true))
+v5 = lift(&, Bool, Nullable(false), Nullable(false))
+v6 = lift(&, Bool, Nullable(false), Nullable{Bool}())
+v7 = lift(&, Bool, Nullable{Bool}(), Nullable(true))
+v8 = lift(&, Bool, Nullable{Bool}(), Nullable(false))
+v9 = lift(&, Bool, Nullable{Bool}(), Nullable{Bool}())
+
+@test isequal(v1, Nullable(true))
+@test isequal(v2, Nullable(false))
+@test isequal(v3, Nullable{Bool}())
+@test isequal(v4, Nullable(false))
+@test isequal(v5, Nullable(false))
+@test isequal(v6, Nullable(false))
+@test isequal(v7, Nullable{Bool}())
+@test isequal(v8, Nullable(false))
+@test isequal(v9, Nullable{Bool}())
+
+# | truth table
+u1 = lift(|, Bool, Nullable(true), Nullable(true))
+u2 = lift(|, Bool, Nullable(true), Nullable(false))
+u3 = lift(|, Bool, Nullable(true), Nullable{Bool}())
+u4 = lift(|, Bool, Nullable(false), Nullable(true))
+u5 = lift(|, Bool, Nullable(false), Nullable(false))
+u6 = lift(|, Bool, Nullable(false), Nullable{Bool}())
+u7 = lift(|, Bool, Nullable{Bool}(), Nullable(true))
+u8 = lift(|, Bool, Nullable{Bool}(), Nullable(false))
+u9 = lift(|, Bool, Nullable{Bool}(), Nullable{Bool}())
+
+@test isequal(u1, Nullable(true))
+@test isequal(u2, Nullable(true))
+@test isequal(u3, Nullable(true))
+@test isequal(u4, Nullable(true))
+@test isequal(u5, Nullable(false))
+@test isequal(u6, Nullable{Bool}())
+@test isequal(u7, Nullable(true))
+@test isequal(u8, Nullable{Bool}())
+@test isequal(u9, Nullable{Bool}())