diff --git a/base/exports.jl b/base/exports.jl
index 2971b68c4194a..78db50604ec53 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -28,6 +28,7 @@ export
     AbstractSparseVector,
     AbstractVector,
     AbstractVecOrMat,
+    AlephNull,
     Array,
     Associative,
     Bidiagonal,
@@ -198,6 +199,7 @@ export
     catalan,
     φ, golden,
     I,
+    ℵ₀,
 
 # Operators
     !,
diff --git a/base/iterator.jl b/base/iterator.jl
index 6b1bc4a6c2b27..ce38a5706ab1c 100644
--- a/base/iterator.jl
+++ b/base/iterator.jl
@@ -1,5 +1,38 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+# For unbounded length iterators
+immutable AlephNull <: Number
+end
+
+show(io::IO, ::AlephNull) = print(io, "ℵ₀")
+const ℵ₀ = AlephNull()
+
+==(::Integer,::AlephNull) = false
+==(::AlephNull,::Integer) = false
+==(::AlephNull,::AlephNull) = true
+
+<(::Integer,::AlephNull) = true
+<(::AlephNull,::Integer) = false
+<(::AlephNull,::AlephNull) = false
+
+<=(::Integer,::AlephNull) = true
+<=(::AlephNull,::Integer) = false
+<=(::AlephNull,::AlephNull) = true
+
+min(x::Integer, ::AlephNull) = x
+min(::AlephNull, x::Integer) = x
+min(::AlephNull, ::AlephNull) = AlephNull()
+
+max(::Integer, ::AlephNull) = AlephNull()
+max(::AlephNull, ::Integer) = AlephNull()
+max(::AlephNull, ::AlephNull) = AlephNull()
+
++(::Integer, ::AlephNull) = AlephNull()
++(::AlephNull, ::Integer) = AlephNull()
++(::AlephNull, ::AlephNull) = AlephNull()
+
+-(::AlephNull, ::Integer) = AlephNull()
+
 isempty(itr) = done(itr, start(itr))
 
 # enumerate
@@ -120,6 +153,7 @@ countfrom(start::Number)               = Count(start, one(start))
 countfrom()                            = Count(1, 1)
 
 eltype{S}(it::Count{S}) = S
+length(it::Count) = AlephNull()
 
 start(it::Count) = it.start
 next(it::Count, state) = (state, state + it.step)
@@ -134,6 +168,7 @@ end
 take(xs, n::Int) = Take(xs, n)
 
 eltype(it::Take) = eltype(it.xs)
+length(it::Take) = min(length(it.xs), it.n)
 
 start(it::Take) = (it.n, start(it.xs))
 
@@ -157,6 +192,7 @@ end
 drop(xs, n::Int) = Drop(xs, n)
 
 eltype(it::Drop) = eltype(it.xs)
+length(it::Drop) = max(length(it.xs)-it.n, 0)
 
 function start(it::Drop)
     xs_state = start(it.xs)
@@ -181,6 +217,7 @@ end
 cycle(xs) = Cycle(xs)
 
 eltype(it::Cycle) = eltype(it.xs)
+length(it::Cycle) = AlephNull()
 
 function start(it::Cycle)
     s = start(it.xs)
@@ -205,6 +242,8 @@ immutable Repeated{O}
 end
 repeated(x) = Repeated(x)
 eltype{O}(r::Repeated{O}) = O
+length(x::Repeated) = AlephNull()
+
 start(it::Repeated) = nothing
 next(it::Repeated, state) = (it.x, nothing)
 done(it::Repeated, state) = false
diff --git a/doc/stdlib/collections.rst b/doc/stdlib/collections.rst
index ef9bb1de368cf..7a758d38d35d5 100644
--- a/doc/stdlib/collections.rst
+++ b/doc/stdlib/collections.rst
@@ -122,6 +122,20 @@ General Collections
 
    For ordered, indexable collections, the maximum index ``i`` for which ``getindex(collection, i)`` is valid. For unordered collections, the number of elements.
 
+   If the collection is infinite (e.g. :func:`repeated`), then the function returns ``ℵ₀``, an instance of the singleton type :obj:`AlephNull`.
+
+.. function:: AlephNull()
+
+   A singleton type with instance ``ℵ₀`` representing the cardinality of the set of natural numbers. Its main purpose is to provide a well-defined :func:`length` of infinite iterators, and its use outside this context is discouraged.
+
+   .. doctest::
+
+      julia> length(repeated(1))
+      ℵ₀
+
+      julia> min(ℵ₀,5)
+      5
+
 .. function:: endof(collection) -> Integer
 
    Returns the last index of the collection.
diff --git a/test/functional.jl b/test/functional.jl
index 9df37f2d4c52f..ed16f7c127fc1 100644
--- a/test/functional.jl
+++ b/test/functional.jl
@@ -49,6 +49,9 @@ let b = IOBuffer("1\n2\n3\n"), a = []
     end
     @test a == [(1,"1\n"),(2,"2\n"),(3,"3\n")]
 end
+@test length(enumerate(1:3)) == 3
+@test length(repeated(0)) == ℵ₀
+
 
 # zip eachline (issue #7369)
 let zeb     = IOBuffer("1\n2\n3\n4\n5\n"),
@@ -58,6 +61,9 @@ let zeb     = IOBuffer("1\n2\n3\n4\n5\n"),
         push!(res, (parse(Int,strip(number)), letter))
     end
     @test res == [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]
+    @test length(zip(letters, 1:10)) == 5
+    @test length(zip(letters, countfrom(1))) == 5
+    @test length(zip(letters, 1:3)) == 3
 end
 
 # rest
@@ -67,6 +73,8 @@ let s = "hello"
     @test collect(rest(s, st)) == ['e','l','l','o']
 end
 
+
+
 # countfrom
 # ---------
 
@@ -77,6 +85,8 @@ let i = 0
         i <= 10 || break
     end
 end
+@test length(countfrom(0,2)) == ℵ₀
+@test length(countfrom(0)) == ℵ₀
 
 # take
 # ----
@@ -99,6 +109,10 @@ let i = 0
     @test i == 10
 end
 
+@test length(take(1:10,5)) == 5
+@test length(take(1:10,15)) == 10
+@test length(take(countfrom(1),5)) == 5
+
 # drop
 # ----
 
@@ -110,6 +124,11 @@ let i = 0
     @test i == 4
 end
 
+@test length(drop(1:10,5)) == 5
+@test length(drop(1:10,15)) == 0
+@test length(drop(countfrom(0),5)) == ℵ₀
+
+
 # cycle
 # -----
 
@@ -121,6 +140,8 @@ let i = 0
     end
 end
 
+@test length(cycle(0:3)) == ℵ₀
+
 # repeated
 # --------
 
@@ -138,3 +159,6 @@ let i = 0
         i <= 10 || break
     end
 end
+
+@test length(repeated(1)) == ℵ₀
+@test length(repeated(1,10)) == 10