Add eltype methods for Nullable

base/nullable.jl

@@ -11,6 +11,10 @@ end
 
 Nullable{T}(value::T) = Nullable{T}(value)
 
+eltype{T}(::Type{Nullable{T}}) = T
+
+eltype{T}(x::Nullable{T}) = T
+
 function convert{S, T}(::Type{Nullable{T}}, x::Nullable{S})
  return isnull(x) ? Nullable{T}() : Nullable(convert(T, get(x)))
 end

doc/stdlib/base.rst

@@ -1306,6 +1306,22 @@ Dequeues
 
 Fully implemented by: ``Vector`` (aka 1-d ``Array``), ``BitVector`` (aka 1-d ``BitArray``).
 
+Nullables
+---------
+
+.. function:: get(x)
+
+ Attempt to access the value of the ``Nullable`` object, ``x``. Returns the
+ value if it is present; otherwise, throws a ``NullException``.
+
+.. function:: get(x, y)
+
+ Attempt to access the value of the ``Nullable{T}`` object, ``x``. Returns
+ the value if it is present; otherwise, returns ``convert(T, y)``.
+
+.. function:: isnull(x)
+
+ Does the ``Nullable`` object ``x`` have a value or not?
 
 Strings
 -------
@@ -3216,7 +3232,7 @@ Mathematical Functions
 .. function:: trunc([T,] x, [digits, [base]])
 
  ``trunc(x)`` returns the nearest integral value of the same type as ``x`` whose absolute
- value is less than or equal to ``x``. 
+ value is less than or equal to ``x``.
 
  ``trunc(T, x)`` converts the result to type ``T``, throwing an
  ``InexactError`` if the value is not representable.
@@ -3228,7 +3244,7 @@ Mathematical Functions
  ``unsafe_trunc(T, x)`` returns the nearest integral value of type ``T`` whose absolute
  value is less than or equal to ``x``. If the value is not representable by
  ``T``, an arbitrary value will be returned.
- 
+
 .. function:: signif(x, digits, [base])
 
  Rounds (in the sense of ``round``) ``x`` so that there are ``digits`` significant digits, under a base ``base`` representation, default 10. E.g., ``signif(123.456, 2)`` is ``120.0``, and ``signif(357.913, 4, 2)`` is ``352.0``.

test/nullable.jl

@@ -19,6 +19,8 @@ for T in types
  x = Nullable{T}()
  @test x.isnull === true
  @test isa(x.value, T)
+ @test eltype(Nullable{T}) === T
+ @test eltype(x) === T
 end
 
 # Nullable{T}(value::T) = new(false, value)
@@ -27,11 +29,13 @@ for T in types
  @test x.isnull === false
  @test isa(x.value, T)
  @test x.value === zero(T)
+ @test eltype(x) === T
 
  x = Nullable{T}(one(T))
  @test x.isnull === false
  @test isa(x.value, T)
  @test x.value === one(T)
+ @test eltype(x) === T
 end
 
 # immutable NullException <: Exception