RFC: Missing values by Sentinels

base/sentinels.jl

@@ -0,0 +1,158 @@
+# TODO
+# Comprehensive arithmetic operators
+# Comprehensive elementary math functions
+# Many cases of Number should actually be {Bool, Int32, ...} for all Optionable types
+# Subclass Option <: Number - this causes many ambiguities
+#   zero, one, inverse functions after Number subclass
+
+import Base
+import Base.show
+import Base.sin
+import Base.promote_rule
+import Base.convert
+
+immutable Option{T<:Number}
+    val::T
+end
+
+const _na_bool = 2
+const _na_int32 = -2147483648               # Smallest integer
+const _na_int64 = -9223372036854775808      # Smallest integer
+const _na_float32 = 0x7f8007a2              # NaN + 1954 mantissa
+const _na_float64 = 0x7ff00000000007a2      # NaN + 1954 mantissa
+
+NAof(::Bool) = _na_bool
+NAof(::Int32) = _na_int32
+NAof(::Int64) = _na_int64
+NAof(::Float32) = _na_float32
+NAof(::Float64) = _na_float64
+NAof(x::Complex) = Complex(NAof(x.real), NAof(x.imag))
+
+isNA(v::Any) = false
+isNA(v::Option) = v.val == NAof(v.val)
+
+
+function show(io::IO, x::Option)
+    if isNA(x)
+        print(io, "NA")
+    else
+        show(io, x.val)
+    end
+end
+
+
+function convert{T<:Number}(::Type{Option{T}}, x::Number)
+    if x == NAof(x)  # This should be very rare
+        throw(TypeError("Value overlaps with NA sentinel value"))
+    else
+        return Option{T}(x)
+    end
+end
+
+
+# Not certain if all of these are necessary
+promote_rule{T<:Number, S<:Number}(::Type{Option{T}}, ::Type{Option{S}}) =
+    Option{promote_rule(T, S)}
+promote_rule{T<:Number, S<:Number}(::Type{T}, ::Type{Option{S}}) =
+    Option{promote_rule(T, S)}
+promote_rule{T<:Number, S<:Number}(::Type{Option{T}}, ::Type{S}) =
+    Option{promote_rule(T, S)}
+
+
+# Remove NA values from an Option array
+# > x = Array{Option{Int32}}([1, 2, NA, 4])
+# > nonnull(x)
+# [1, 2, 4]
+function nonnull{T}(arr::Array{Option{T}})
+    result = Array{T}([])
+    for item in x
+        if !isNA(item)
+            push!(result, item.val)
+        end
+    end
+    return result
+end
+
+
+# Fill an Option array with concrete values
+# > x = Array{Option{Int32}}([1, 2, NA, 4])
+# > fill(x, -1)
+# [1, 2, -1, 4]
+function fill{T, S}(arr::Array{Option{T}}, fillvalue::S)
+    result = Array{promote_type(T, S)}([])
+    for item in x
+        if isNA(item)
+            push!(result, fillvalue)
+        else
+            push!(result, item.val)
+        end
+    end
+    return result
+end
+
+
+# Arithmetic binary operators
+^(x::Option, y::Integer) = isNA(x) ? x : $op(x.val, y)  # To avoid an ambiguity
+for op in [:+, :-, :/, :*, :^, :%]
+    @eval function $op(x::Option, y::Option)  # and make sure this is replicated
+        if isNA(x)
+            return x
+        elseif isNA(y)
+            return y
+        else
+            return Option($op(x.val, y.val))
+        end
+    end
+    @eval $op(x::Option, y::Number) = isNA(x) ? x : Option($op(x.val, y))
+    @eval $op(x::Number, y::Option) = isNA(y) ? y : Option($op(x, y.val))
+end
+
+
+# Boolean binary operators
+for op in [:(Base.(:(==))), :(Base.(:(<=))), :(Base.(:(>=))), :(Base.(:(<))),
+    :(Base.(:(>)))]
+    @eval function $op(x::Option, y::Option)  # and make sure this is replicated
+        if isNA(x) | isNA(y)
+            result = NA_Bool
+        else
+            result = x.val == y.val
+        end
+        return Option(result)
+    end
+    @eval $op(x::Option, y::Number) = isNA(x) ? x : Option{Bool}($op(x.val, y))
+    @eval $op(x::Number, y::Option) = isNA(y) ? y : Option{Bool}($op(x, y.val))
+end
+
+
+# Unary operators
+!(x::Option{Bool}) = isNA(x) ? x : Option{Bool}(!x.val)
+-(x::Option{Number}) = isNA(x) ? x : Option(-x.val)
+
+
+# Mathematical Unary Functions -- TODO: need more extensive list
+for op in [:(Base.sin), :(Base.cos), :(Base.tan), :(Base.exp), :(Base.log)]
+    @eval $op(x::Option) = isNA(x) ? x : Option($op(x.val))
+end
+
+
+const NA_Bool = Option{Bool}(_na_bool)
+const NA_Int32 = Option{Int32}(_na_int32)
+const NA_Int64 = Option{Int64}(_na_int64)
+const NA_Float32 = Option{Float32}(_na_float32)
+const NA_Float64 = Option{Float64}(_na_float64)
+
+
+# Singleton NA value
+# x = Array{Option{Int32}}([1, 2, NA, 4])
+# Should this share an abstract `Optional` type with `Option`?
+immutable NA_Type end
+
+const NA = NA_Type()
+isNA(::NA_Type) = true
+
+promote_rule{T}(::Type{NA_Type}, ::Type{Option{T}}) = Option{T}
+
+convert{T}(::Type{Option{T}}, ::NA_Type) = Option{T}(NAof(T(0)))
+function show(io::IO, x::NA_Type)
+    print(io, "NA")
+end