From 5033b36c442c7a2d2c3637b7d8da16666c1a21ea Mon Sep 17 00:00:00 2001
From: Guido van Rossum <guido@python.org>
Date: Tue, 20 Aug 2002 21:38:37 +0000
Subject: [PATCH] Move __init__ from BaseSet into Set and ImmutableSet.  This
 causes a tiny amount of code duplication, but makes it possible to give
 BaseSet an __init__ that raises an exception.

---
 Lib/sets.py | 44 ++++++++++++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 16 deletions(-)

diff --git a/Lib/sets.py b/Lib/sets.py
index 4df30f81466..c301c4183be 100644
--- a/Lib/sets.py
+++ b/Lib/sets.py
@@ -63,20 +63,12 @@ class BaseSet(object):
 
     # Constructor
 
-    def __init__(self, seq=None):
-        """Construct a set, optionally initializing it from a sequence."""
-        self._data = {}
-        if seq is not None:
-            # I don't know a faster way to do this in pure Python.
-            # Custom code written in C only did it 65% faster,
-            # preallocating the dict to len(seq); without
-            # preallocation it was only 25% faster.  So the speed of
-            # this Python code is respectable.  Just copying True into
-            # a local variable is responsible for a 7-8% speedup.
-            data = self._data
-            value = True
-            for key in seq:
-                data[key] = value
+    def __init__(self):
+        """This is an abstract class."""
+        # Don't call this from a concrete subclass!
+        if self.__class__ is BaseSet:
+            raise NotImplementedError, ("BaseSet is an abstract class.  "
+                                        "Use Set or ImmutableSet.")
 
     # Standard protocols: __len__, __repr__, __str__, __iter__
 
@@ -289,9 +281,19 @@ class ImmutableSet(BaseSet):
 
     def __init__(self, seq):
         """Construct an immutable set from a sequence."""
-        # Override the constructor to make 'seq' a required argument
-        BaseSet.__init__(self, seq)
         self._hashcode = None
+        self._data = data = {}
+        # I don't know a faster way to do this in pure Python.
+        # Custom code written in C only did it 65% faster,
+        # preallocating the dict to len(seq); without
+        # preallocation it was only 25% faster.  So the speed of
+        # this Python code is respectable.  Just copying True into
+        # a local variable is responsible for a 7-8% speedup.
+        value = True
+        # XXX Should this perhaps look for _as_immutable?
+        # XXX If so, should use self.update(seq).
+        for key in seq:
+            data[key] = value
 
     def __hash__(self):
         if self._hashcode is None:
@@ -306,6 +308,16 @@ class Set(BaseSet):
 
     # BaseSet + operations requiring mutability; no hashing
 
+    def __init__(self, seq=None):
+        """Construct an immutable set from a sequence."""
+        self._data = data = {}
+        if seq is not None:
+            value = True
+            # XXX Should this perhaps look for _as_immutable?
+            # XXX If so, should use self.update(seq).
+            for key in seq:
+                data[key] = value
+
     # In-place union, intersection, differences
 
     def union_update(self, other):