experimental functional operations on nullables as collections

Author: TotalVerb

src/NullableArrays.jl

@@ -30,4 +30,9 @@ include("reduce.jl")
 include("show.jl")
 include("subarray.jl")
 
+if VERSION ≥ v"0.5-"
+    include("functional.jl")
+    using .FunctionalNullableOperations
+end
+
 end

src/functional.jl

@@ -0,0 +1,126 @@
+module FunctionalNullableOperations
+
+# extends Base with operations that treat nullables as collections
+
+importall Base
+import Base: promote_op, LinearFast
+
+# conceptually, nullable types can be considered infinite-order tensor powers of
+# finite-dimensional vector spaces — we attempt to support most operations on
+# arrays except the linear algebra related ones; the infinite-dimensional nature
+# makes subtyping AbstractArray a little dangerous, which explains why
+# functionality is reimplemented instead of subtyping AbstractArray
+
+# size   – not implemented since an infinite-dimensional tuple would be strange
+# length – one or zero
+# endof  – same as length
+length(u::Nullable) = u.isnull ? 0 : 1
+endof(u::Nullable)  = length(u)
+
+# indexing is either without index, or with 1 as index
+# generalized linear indexing is not supported
+# setindex! not supported because Nullable is immutable
+linearindexing{T}(::Nullable{T}) = LinearFast()
+function getindex(u::Nullable)
+    @boundscheck u.isnull && throw(NullException())
+    u.value
+end
+function getindex(u::Nullable, i::Integer)
+    @boundscheck u.isnull | (i ≠ one(i)) && throw(BoundsError(i, u))
+    u.value
+end
+
+# iteration protocol
+start(u::Nullable) = 1
+next(u::Nullable, i::Integer) = u.value, 0
+done(u::Nullable, i::Integer) = u.isnull || i == 0
+
+# next we have reimplementations of some higher-order functions
+filter{T}(p, u::Nullable{T}) = u.isnull ? u : p(u.value) ? u : Nullable{T}()
+
+# warning: not type-stable
+map{T}(f, u::Nullable{T}) = u.isnull ? Nullable{Union{}}() : Nullable(f(u.value))
+
+# multi-argument map doesn't broadcast, so not very useful, but no harm having
+# it...
+function map(f, us::Nullable...)
+    if all(isnull, us)
+        Nullable()
+    elseif !any(isnull, us)
+        Nullable(map(f, map(getindex, us)...))
+    else
+        throw(DimensionMismatch("expected all null or all nonnull"))
+    end
+end
+
+# foldr and foldl are quite useful to express "do something if not null, else"
+# these
+
+# being infinite-dimensional, nullables are generally incompatible with
+# broadcast with arrays — it is probably not worth supporting the rare case
+# where an array has length 0 or 1
+
+# so we reimplement broadcast, which has the same semantics but very different
+# implementation. This implementation is in fact much simpler than that for
+# arrays. Length-1 (non-nulls) are flexible and can broadcast to length-0
+# (nulls), but the other way does not work. Numbers are zero-dimensional and can
+# broadcast to infinite-dimensional nullables, but the other direction is not
+# supported.
+
+# there are two shapes we are concerned about: infinite-dimensional 1×1×...
+# and infinite-dimensional 0×0×...; we don't care about zero-dimensional because
+# in that case all arguments were numbers, and broadcasting over only numbers
+# isn't supported by base currently
+function nullable_broadcast_shape(us::Union{Nullable,Number}...)
+    for u in us
+        if isa(us, Nullable)
+            if u.isnull
+                return true
+            end
+        end
+    end
+    return false
+end
+
+# Base's broadcast has a very loose signature so we can easily make it more
+# specific. Broadcast on numbers is still not supported. FIXME: remove generated
+# functions where unnecessary
+
+# some specialized functions
+broadcast{T}(f, u::Nullable{T}) =
+    u.isnull ? Nullable{promote_op(f, T)}() : Nullable{promote_op(f, T)}(f(u.value))
+
+@generated function broadcast(f, u::Union{Nullable,Number}, v::Union{Nullable,Number})
+    checkfor(s) = :($s.isnull && return Nullable{result}())
+    lifted = [T <: Nullable ? T.parameters[1] : T for T in (u, v)]
+    checks = vcat(u <: Nullable ? [checkfor(:u)] : [],
+                  v <: Nullable ? [checkfor(:v)] : [])
+    quote
+        result = promote_op(f, $(lifted...))
+        $(checks...)
+        @inbounds return Nullable{result}(f(u[], v[]))
+    end
+end
+
+# functions with three arguments or more are a bit expensive to specialize...
+# FIXME: why the arbitrary cutoff? justify
+function broadcast(f, us::Union{Nullable, Number}...)
+    result = promote_op(f,
+        [T <: Nullable ? T.parameters[1] : T for T in map(typeof, us)]...)
+    for u in us
+        if isa(u, Nullable) && u.isnull
+            return Nullable{result}()
+        end
+    end
+    @inbounds return Nullable{result}(f(map(getindex, us)...))
+end
+
+# FIXME: these operations are probably not all correct
+# and definitely some of them are slow, needs specialization
+# also have to be careful to avoid ambiguities... needs testing
+for eop in :(.+, .-, .*, ./, .\, .//, .==, .<, .!=, .<=, .÷, .%, .<<, .>>, .^).args
+    @eval $eop(u::Nullable, v::Union{Nullable, Number}) = broadcast($eop, u, v)
+    @eval $eop(u::Number, v::Nullable) = broadcast($eop, u, v)
+end
+
+end # module

test/functional.jl

@@ -0,0 +1,108 @@
+module TestFunctional
+
+# nullable equality is a little strange... we need a "is a null with type T"
+# and a "is a nullable with value egal to k"
+
+# these functions are curried for readability
+isnull_typed(u::Nullable, T::Type) = typeof(u).parameters[1] == T && isnull(u)
+isnull_typed(t::Type) = u -> isnull_typed(u, t)
+
+isnullableof(u::Nullable, x) = !isnull(u) && u.value === x
+isnullableof(x) = u -> isnullableof(u, x)
+
+using Base.Test
+
+# getindex
+@test_throws NullException Nullable()[]
+@test_throws NullException Nullable{Int}()[]
+@test Nullable(0)[] == 0
+
+@test_throws BoundsError Nullable()[1]
+@test_throws BoundsError Nullable(0)[0]
+@test_throws BoundsError Nullable(0)[2]
+@test Nullable(0)[1] == 0
+
+# collect
+@test collect(Nullable()) == Union{}[]
+@test collect(Nullable{Int}()) == Int[]
+@test collect(Nullable(85)) == Int[85]
+@test collect(Nullable(1.0)) == Float64[1.0]
+
+# length
+@test length(Nullable()) == 0
+@test length(Nullable{Int}()) == 0
+@test length(Nullable(1.0)) == 1
+@test endof(Nullable(85)) == 1
+
+# filter
+for p in (_ -> true, _ -> false)
+    @test filter(p, Nullable())      |> isnull_typed(Union{})
+    @test filter(p, Nullable{Int}()) |> isnull_typed(Int)
+end
+@test filter(_ -> true, Nullable(85))  |> isnullableof(85)
+@test filter(_ -> false, Nullable(85)) |> isnull_typed(Int)
+@test filter(x -> x > 0, Nullable(85)) |> isnullableof(85)
+@test filter(x -> x < 0, Nullable(85)) |> isnull_typed(Int)
+
+# map
+sqr(x) = x^2
+@test map(sqr, Nullable())      |> isnull_typed(Union{})
+@test map(sqr, Nullable{Int}()) |> isnull_typed(Union{})  # type-unstable (!)
+@test map(sqr, Nullable(2))     |> isnullableof(4)
+
+@test map(+, Nullable(1), Nullable(2), Nullable(3)) |> isnullableof(6)
+@test map(+, Nullable(), Nullable(), Nullable())    |> isnull_typed(Union{})
+@test map(+, Nullable{Int}(), Nullable{Int}())      |> isnull_typed(Union{})
+
+# example: square if value exists, -1 if value is null
+# with foldl/foldr/reduce
+for fn in (foldl, foldr, reduce)
+    @test foldl((_, x) -> x^2, -1, Nullable())   == -1
+    @test foldl((_, x) -> x^2, -1, Nullable(10)) == 100
+end
+
+# with broadcast and get (map does not work because of get limitations...)
+# perhaps the get limitations should be fixed
+@test get(sqr.(Nullable{Int}()), -1) == -1
+@test get(sqr.(Nullable(10)), -1)    == 100
+
+# broadcast and elementwise
+@test sin.(Nullable(0.0))             |> isnullableof(0.0)
+@test sin.(Nullable{Float64}())       |> isnull_typed(Float64)
+
+@test Nullable(8) .+ Nullable(10)     |> isnullableof(18)
+@test Nullable(8) .- Nullable(10)     |> isnullableof(-2)
+@test Nullable(8) .+ Nullable{Int}()  |> isnull_typed(Int)
+@test Nullable{Int}() .- Nullable(10) |> isnull_typed(Int)
+
+@test log.(10, Nullable(1.0))         |> isnullableof(0.0)
+@test log.(10, Nullable{Float64}())   |> isnull_typed(Float64)
+
+@test Nullable(2) .^ Nullable(4)      |> isnullableof(16)
+@test Nullable(2) .^ Nullable{Int}()  |> isnull_typed(Int)
+
+# big broadcast (slow)
+@test Nullable(1) .+ Nullable(1) .+ Nullable(1) .+ Nullable(1) .+ Nullable(1) .+
+    Nullable(1) |> isnullableof(6)
+@test Nullable(1) .+ Nullable(1) .+ Nullable(1) .+ Nullable{Int}() .+
+    Nullable(1) .+ Nullable(1) |> isnull_typed(Int)
+
+# very slow but it should work
+us = map(Nullable, 1:20)
+@test broadcast(max, us...)                  |> isnullableof(20)
+@test broadcast(max, us..., Nullable{Int}()) |> isnull_typed(Int)
+
+# imperative style
+s = 0
+for x in Nullable(10)
+    s += x
+end
+@test s == 10
+
+s = 0
+for x in Nullable{Int}()
+    s += x
+end
+@test s == 0
+
+end

test/runtests.jl

@@ -4,7 +4,7 @@ fatalerrors = length(ARGS) > 0 && ARGS[1] == "-f"
 quiet = length(ARGS) > 0 && ARGS[1] == "-q"
 anyerrors = false
 
-my_tests = [
+my_tests = [] #= [
     "typedefs.jl",
     "constructors.jl",
     "primitives.jl",
@@ -17,7 +17,11 @@ my_tests = [
     "operators.jl",
     "subarray.jl",
     "show.jl",
-]
+] =#
+
+if VERSION ≥ v"0.5-"
+    push!(my_tests, "functional.jl")
+end
 
 println("Running tests:")