diff --git a/base/inference.jl b/base/inference.jl
index c65579288cdd1..56336bd11f878 100644
--- a/base/inference.jl
+++ b/base/inference.jl
@@ -34,10 +34,18 @@ typealias VarTable Array{Any,1}
 type VarState
     typ
     undef::Bool
+    function VarState(typ::ANY, undef::Bool)
+        if isa(typ, DataType) && isdefined(typ, :instance)
+            # replace singleton types with their equivalent Const object
+            typ = Const(typ.instance)
+        end
+        return new(typ, undef)
+    end
 end
 
 immutable Const
     val
+    Const(v::ANY) = new(v)
 end
 
 type InferenceState
diff --git a/base/irrationals.jl b/base/irrationals.jl
index 2ecf1f59dacaf..590ec1e3e768d 100644
--- a/base/irrationals.jl
+++ b/base/irrationals.jl
@@ -57,27 +57,44 @@ end
     x < big(y)
 end
 
-<=(x::Irrational,y::AbstractFloat) = x < y
-<=(x::AbstractFloat,y::Irrational) = x < y
+<=(x::Irrational, y::AbstractFloat) = x < y
+<=(x::AbstractFloat, y::Irrational) = x < y
 
 # Irrational vs Rational
-@generated function <{T}(x::Irrational, y::Rational{T})
-    bx = big(x())
-    bx < 0 && T <: Unsigned && return true
-    rx = rationalize(T,bx,tol=0)
-    rx < bx ? :($rx < y) : :($rx <= y)
+@pure function rationalize{T<:Integer}(::Type{T}, x::Irrational; tol::Real=0)
+    return rationalize(T, big(x), tol=tol)
 end
-@generated function <{T}(x::Rational{T}, y::Irrational)
-    by = big(y())
-    by < 0 && T <: Unsigned && return false
-    ry = rationalize(T,by,tol=0)
-    ry < by ? :(x <= $ry) : :(x < $ry)
+@pure function rationalize{T<:Integer}(::Type{T}, x::Irrational)
+    return rationalize(T, big(x), tol=0)
+end
+@pure function lessrational{T<:Integer}(rx::Rational{T}, x::Irrational)
+    # an @pure version of `<` for determining if the rationalization of
+    # an irrational number required rounding up or down
+    return rx < big(x)
+end
+function <{T}(x::Irrational, y::Rational{T})
+    T <: Unsigned && x < 0.0 && return true
+    rx = rationalize(T, x)
+    if lessrational(rx, x)
+        return rx < y
+    else
+        return rx <= y
+    end
+end
+function <{T}(x::Rational{T}, y::Irrational)
+    T <: Unsigned && y < 0.0 && return false
+    ry = rationalize(T, y)
+    if lessrational(ry, y)
+        return x <= ry
+    else
+        return x < ry
+    end
 end
 <(x::Irrational, y::Rational{BigInt}) = big(x) < y
 <(x::Rational{BigInt}, y::Irrational) = x < big(y)
 
-<=(x::Irrational,y::Rational) = x < y
-<=(x::Rational,y::Irrational) = x < y
+<=(x::Irrational, y::Rational) = x < y
+<=(x::Rational, y::Irrational) = x < y
 
 isfinite(::Irrational) = true