Index: Objects/rangeobject.c
===================================================================
--- Objects/rangeobject.c	(revision 62564)
+++ Objects/rangeobject.c	(working copy)
@@ -14,6 +14,7 @@
     PyObject *start;
     PyObject *stop;
     PyObject *step;
+    Py_ssize_t length;
 } rangeobject;
 
 /* Helper function for validating step.  Always returns a new reference or
@@ -43,6 +44,9 @@
     return step;
 }
 
+static Py_ssize_t range_compute_length(PyObject *start,
+				       PyObject *stop, PyObject *step);
+
 /* XXX(nnorwitz): should we error check if the user passes any empty ranges?
    range(-10)
    range(0, -5)
@@ -53,6 +57,7 @@
 {
     rangeobject *obj = NULL;
     PyObject *start = NULL, *stop = NULL, *step = NULL;
+    Py_ssize_t length;
 
     if (!_PyArg_NoKeywords("range()", kw))
         return NULL;
@@ -81,12 +86,16 @@
             goto Fail;
     }
 
+    length = range_compute_length(start, stop, step);
+    if (length < 0)
+	goto Fail;
     obj = PyObject_New(rangeobject, &PyRange_Type);
     if (obj == NULL)
         goto Fail;
     obj->start = start;
     obj->stop = stop;
     obj->step = step;
+    obj->length = length;
     return (PyObject *) obj;
 
 Fail:
@@ -99,7 +108,7 @@
 PyDoc_STRVAR(range_doc,
 "range([start,] stop[, step]) -> range object\n\
 \n\
-Returns an iterator that generates the numbers in the range on demand.");
+Returns a virtual sequence of numbers from start to stop by step.");
 
 static void
 range_dealloc(rangeobject *r)
@@ -116,16 +125,16 @@
  * Arguments MUST return 1 with either PyLong_Check() or
  * PyLong_Check().  Return -1 when there is an error.
  */
-static PyObject*
-range_length_obj(rangeobject *r)
+static Py_ssize_t
+range_compute_length(PyObject *start, PyObject *stop, PyObject *step)
 {
     /* -------------------------------------------------------------
     Algorithm is equal to that of get_len_of_range(), but it operates
     on PyObjects (which are assumed to be PyLong or PyInt objects).
     ---------------------------------------------------------------*/
+    Py_ssize_t length;
     int cmp_result, cmp_call;
     PyObject *lo, *hi;
-    PyObject *step = NULL;
     PyObject *diff = NULL;
     PyObject *one = NULL;
     PyObject *tmp1 = NULL, *tmp2 = NULL, *result;
@@ -133,30 +142,29 @@
 
     PyObject *zero = PyLong_FromLong(0);
     if (zero == NULL)
-        return NULL;
-    cmp_call = PyObject_Cmp(r->step, zero, &cmp_result);
+        return -1;
+    cmp_call = PyObject_Cmp(step, zero, &cmp_result);
     Py_DECREF(zero);
     if (cmp_call == -1)
-        return NULL;
+        return -1;
 
     assert(cmp_result != 0);
     if (cmp_result > 0) {
-        lo = r->start;
-        hi = r->stop;
-        step = r->step;
+        lo = start;
+        hi = stop;
         Py_INCREF(step);
     } else {
-        lo = r->stop;
-        hi = r->start;
-        step = PyNumber_Negative(r->step);
+        lo = stop;
+        hi = start;
+        step = PyNumber_Negative(step);
         if (!step)
-            return NULL;
+            return -1;
     }
 
     /* if (lo >= hi), return length of 0. */
     if (PyObject_Compare(lo, hi) >= 0) {
         Py_XDECREF(step);
-        return PyLong_FromLong(0);
+        return 0;
     }
 
     if ((one = PyLong_FromLong(1L)) == NULL)
@@ -179,7 +187,12 @@
     Py_DECREF(step);
     Py_DECREF(tmp1);
     Py_DECREF(one);
-    return result;
+    length = PyLong_AsSsize_t(result);
+    if (length == -1 && PyErr_ExceptionMatches(PyExc_OverflowError))
+	PyErr_SetString(PyExc_OverflowError, 
+			"range length exceded sys.maxsize");
+    Py_DECREF(result);
+    return length;
 
   Fail:
     Py_XDECREF(tmp2);
@@ -187,38 +200,21 @@
     Py_XDECREF(step);
     Py_XDECREF(tmp1);
     Py_XDECREF(one);
-    return NULL;
+    return -1;
 }
 
 static Py_ssize_t
 range_length(rangeobject *r)
 {
-    PyObject *len = range_length_obj(r);
-    Py_ssize_t result = -1;
-    if (len) {
-        result = PyLong_AsSsize_t(len);
-        Py_DECREF(len);
-    }
-    return result;
+    return r->length;
 }
 
 /* range(...)[x] is necessary for:  seq[:] = range(...) */
-
 static PyObject *
-range_item(rangeobject *r, Py_ssize_t i)
+compute_range_item(rangeobject *r, Py_ssize_t i)
 {
-    Py_ssize_t len = range_length(r);
     PyObject *rem, *incr, *result;
 
-    /* XXX(nnorwitz): should negative indices be supported? */
-    /* XXX(nnorwitz): should support range[x] where x > PY_SSIZE_T_MAX? */
-    if (i < 0 || i >= len) {
-        if (!PyErr_Occurred())
-            PyErr_SetString(PyExc_IndexError,
-                            "range object index out of range");
-        return NULL;
-    }
-
     /* XXX(nnorwitz): optimize for short ints. */
     rem = PyLong_FromSsize_t(i);
     if (!rem)
@@ -233,6 +229,69 @@
 }
 
 static PyObject *
+range_item(rangeobject *r, Py_ssize_t i)
+{
+    /* XXX(nnorwitz): should negative indices be supported? */
+    /* XXX(nnorwitz): should support range[x] where x > PY_SSIZE_T_MAX? */
+    if (i < 0 || i >= r->length) {
+        if (!PyErr_Occurred())
+            PyErr_SetString(PyExc_IndexError,
+                            "range object index out of range");
+        return NULL;
+    }
+    return compute_range_item(r, i);
+}
+
+static int
+range_contains(rangeobject *r, PyObject *el)
+{
+    PyObject *diff = NULL, *rem = NULL, *zero = NULL;
+    int cmp;
+    if (Py_SIZE(r->step) > 0) {
+	cmp = PyObject_RichCompareBool(r->start, el, Py_LE);
+	if (cmp != 1)
+	    goto done;
+	cmp = PyObject_RichCompareBool(el, r->stop, Py_LT);
+	if (cmp != 1)
+	    goto done;
+    }
+    else {
+	cmp = PyObject_RichCompareBool(r->start, el, Py_GT);
+	if (cmp != 1)
+	    goto done;
+	cmp = PyObject_RichCompareBool(el, r->stop, Py_GT);
+	if (cmp != 1)
+	    goto done;
+    }
+    /* XXX: Optimize for step = 1 and small ints */
+    diff = PyNumber_Subtract(el, r->start);
+    if (diff == NULL) {
+	cmp = -1;
+	goto done;
+    }
+    rem = PyNumber_Remainder(diff, r->step);
+    if (rem == NULL) {
+	cmp = -1;
+	goto done;
+    }
+    zero = PyLong_FromLong(0); 
+    if (zero == NULL) {
+	cmp = -1;
+	goto done;
+    }
+    cmp = PyObject_RichCompareBool(rem, zero, Py_EQ);
+    Py_DECREF(zero);
+ done:
+    Py_XDECREF(rem);
+    Py_XDECREF(diff);
+    if (cmp == -1 && PyErr_ExceptionMatches(PyExc_TypeError)) {
+	PyErr_Clear();
+	return 0;
+    }
+    return cmp;
+}
+
+static PyObject *
 range_repr(rangeobject *r)
 {
     Py_ssize_t istep;
@@ -254,12 +313,84 @@
 
 static PySequenceMethods range_as_sequence = {
     (lenfunc)range_length,	/* sq_length */
-    0,			/* sq_concat */
-    0,			/* sq_repeat */
-    (ssizeargfunc)range_item, /* sq_item */
-    0,			/* sq_slice */
+    0,			        /* sq_concat */
+    0,			        /* sq_repeat */
+    (ssizeargfunc)range_item,   /* sq_item */
+    0,			        /* sq_slice */
+    0,                          /* sq_ass_item */ 
+    0,                          /* sq_ass_slice */ 
+    (objobjproc)range_contains, /* sq_contains */ 
 };
 
+static PyObject *
+range_subscript(rangeobject* self, PyObject* item)
+{
+    if (PyIndex_Check(item)) {
+	Py_ssize_t i;
+	i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+	if (i == -1 && PyErr_Occurred())
+	    return NULL;
+	if (i < 0)
+	    i += self->length;
+	return range_item(self, i);
+    }
+    if (PySlice_Check(item)) {
+	PySliceObject *slice = (PySliceObject*)item;
+	Py_ssize_t start, stop, step, len;
+	rangeobject *result;
+	PyObject *rstart = NULL, *rstep = NULL, *rstop = NULL;
+
+	if (PySlice_GetIndicesEx(slice, self->length,
+				 &start, &stop, &step, &len) < 0) {
+	    return NULL;
+	}
+	if (step == 1) {
+	    rstep = self->step;
+	    Py_INCREF(rstep);
+	} else {
+	    /* NB: slice step != Py_None here */
+	    rstep = PyNumber_Multiply(self->step, slice->step);
+	    if (rstep == NULL)
+		goto fail;
+	}
+	rstart = compute_range_item(self, start);
+	if (rstart == NULL)
+	    goto fail;
+	if (len <= 0) {
+	    rstop = rstart;
+	    Py_INCREF(rstop);
+	}
+	else {
+	    rstop = compute_range_item(self, stop);
+	    if (rstop == NULL)
+		goto fail;
+	}
+	result = (rangeobject*)PyObject_New(rangeobject, &PyRange_Type);
+	if (result == NULL)
+	    return NULL;
+	result->start = rstart;
+	result->stop = rstop;
+	result->step = rstep;
+	return (PyObject*)result;
+    fail:
+	Py_XDECREF(rstart);
+	Py_XDECREF(rstep);
+	Py_XDECREF(rstop);
+	return NULL;
+    }
+    PyErr_Format(PyExc_TypeError,
+		 "range indices must be integers, not %.200s",
+		 item->ob_type->tp_name);
+    return NULL;
+}
+
+
+static PyMappingMethods range_as_mapping = {
+	(lenfunc)range_length,
+	(binaryfunc)range_subscript,
+	(objobjargproc)0,
+};
+
 static PyObject * range_iter(PyObject *seq);
 static PyObject * range_reverse(PyObject *seq);
 
@@ -285,7 +416,7 @@
 	(reprfunc)range_repr,	/* tp_repr */
 	0,			/* tp_as_number */
 	&range_as_sequence,	/* tp_as_sequence */
-	0,			/* tp_as_mapping */
+	&range_as_mapping,	/* tp_as_mapping */
 	0,			/* tp_hash */
 	0,			/* tp_call */
 	0,			/* tp_str */
@@ -647,7 +778,7 @@
         return NULL;
 
     /* start + (len - 1) * step */
-    len = range_length_obj(range);
+    len = PyLong_FromSsize_t(range->length);
     if (!len)
         goto create_failure;
 
Index: Lib/_abcoll.py
===================================================================
--- Lib/_abcoll.py	(revision 62564)
+++ Lib/_abcoll.py	(working copy)
@@ -545,6 +545,7 @@
 
 Sequence.register(tuple)
 Sequence.register(str)
+Sequence.register(range)
 
 
 class ByteString(Sequence):
Index: Lib/test/test_range.py
===================================================================
--- Lib/test/test_range.py	(revision 62564)
+++ Lib/test/test_range.py	(working copy)
@@ -61,6 +61,45 @@
         self.assertEqual(repr(range(1, 2)), 'range(1, 2)')
         self.assertEqual(repr(range(1, 2, 3)), 'range(1, 2, 3)')
 
+    def test_slice(self):
+        def check(start, stop, step=None):
+            i = slice(start, stop, step)
+            self.assertEqual(list(r[i]), list(r)[i])
+        for r in [range(10),
+                  range(0),
+                  range(1, 9, 3),
+                  range(8, 0, -3),
+                  ]:
+            check(0, 2)
+            check(0, 20)
+            check(1, 2)
+            check(20, 30)
+            check(-30, -20)            
+            check(-1, 100, 2)
+            check(0, -1)
+            check(-1, -3, -1)
+            
+    def test_contains(self):
+        r = range(10)
+        self.assertTrue(0 in r)
+        self.assertTrue(5.0 in r)
+        self.assertFalse(-1 in r)
+        self.assertFalse(10 in r)
+        self.assertFalse("" in r)
+        r = range(9, -1, -1)
+        self.assertTrue(0 in r)
+        self.assertTrue(5.0 in r)
+        self.assertFalse(-1 in r)
+        self.assertFalse(10 in r)
+        self.assertFalse("" in r)
+        r = range(0, 10, 2)
+        self.assertTrue(0 in r)
+        self.assertFalse(5.0 in r)
+        self.assertFalse(-1 in r)
+        self.assertFalse(10 in r)
+        self.assertFalse("" in r)
+
+        
 def test_main():
     test.test_support.run_unittest(RangeTest)
 
Index: Lib/test/test_builtin.py
===================================================================
--- Lib/test/test_builtin.py	(revision 62564)
+++ Lib/test/test_builtin.py	(working copy)
@@ -1590,10 +1590,10 @@
         self.assertRaises(TypeError, range, 0, "spam")
         self.assertRaises(TypeError, range, 0, 42, "spam")
 
-        #NEAL self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize)
-        #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxsize)
+        self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize)
+        self.assertRaises(OverflowError, range, 0, 2*sys.maxsize)
 
-        self.assertRaises(OverflowError, len, range(0, sys.maxsize**10))
+        # self.assertRaises(OverflowError, len, range(0, sys.maxsize**10))
 
     def test_input(self):
         self.write_testfile()