Add docstrings for isequal() and isless() on Nullables

Author: nalimilan

base/nullable.jl

@@ -98,6 +98,13 @@ null_safe_op{S<:NullSafeTypes,
 null_safe_op{S<:NullSafeTypes,
              T<:NullSafeTypes}(::typeof(isequal), ::Type{Rational{S}}, ::Type{Rational{T}}) = true
 
+"""
+    isequal(x::Nullable, y::Nullable)
+
+If neither `x` nor `y` is null, compare them according to their values
+(i.e. `isequal(get(x), get(y))`). Else, return `true` if both arguments are null,
+and `false` if one is null but not the other: nulls are considered equal.
+"""
 function isequal{S,T}(x::Nullable{S}, y::Nullable{T})
     if null_safe_op(isequal, S, T)
         (x.isnull & y.isnull) | (!x.isnull & !y.isnull & isequal(x.value, y.value))
@@ -117,6 +124,14 @@ null_safe_op{S<:NullSafeTypes,
 null_safe_op{S<:NullSafeTypes,
              T<:NullSafeTypes}(::typeof(isless), ::Type{Rational{S}}, ::Type{Rational{T}}) = true
 
+"""
+    isless(x::Nullable, y::Nullable)
+
+If neither `x` nor `y` is null, compare them according to their values
+(i.e. `isless(get(x), get(y))`). Else, return `true` if only `y` is null, and `false`
+otherwise: nulls are always considered greater than non-nulls, but not greater than
+another null.
+"""
 function isless{S,T}(x::Nullable{S}, y::Nullable{T})
     # NULL values are sorted last
     if null_safe_op(isless, S, T)

doc/stdlib/base.rst

@@ -263,12 +263,24 @@ All Objects
 
    Scalar types generally do not need to implement ``isequal`` separate from ``==``\ , unless they represent floating-point numbers amenable to a more efficient implementation than that provided as a generic fallback (based on ``isnan``\ , ``signbit``\ , and ``==``\ ).
 
+.. function:: isequal(x::Nullable, y::Nullable)
+
+   .. Docstring generated from Julia source
+
+   If neither ``x`` nor ``y`` is null, compare them according to their values (i.e. ``isequal(get(x), get(y))``\ ). Else, return ``true`` if both arguments are null, and ``false`` if one is null but not the other: nulls are considered equal.
+
 .. function:: isless(x, y)
 
    .. Docstring generated from Julia source
 
    Test whether ``x`` is less than ``y``\ , according to a canonical total order. Values that are normally unordered, such as ``NaN``\ , are ordered in an arbitrary but consistent fashion. This is the default comparison used by ``sort``\ . Non-numeric types with a canonical total order should implement this function. Numeric types only need to implement it if they have special values such as ``NaN``\ .
 
+.. function:: isless(x::Nullable, y::Nullable)
+
+   .. Docstring generated from Julia source
+
+   If neither ``x`` nor ``y`` is null, compare them according to their values (i.e. ``isless(get(x), get(y))``\ ). Else, return ``true`` if only ``y`` is null, and ``false`` otherwise: nulls are always considered greater than non-nulls, but not greater than another null.
+
 .. function:: ifelse(condition::Bool, x, y)
 
    .. Docstring generated from Julia source

doc/stdlib/stacktraces.rst

@@ -17,7 +17,7 @@
    * ``func::Symbol``
 
      The name of the function containing the execution context.
-   * ``linfo::Nullable{MethodInstance}``
+   * ``linfo::Nullable{Core.MethodInstance}``
 
      The MethodInstance containing the execution context (if it could be found).
    * ``file::Symbol``