[Python-checkins] r54976 - sandbox/trunk/abc/abc.py sandbox/trunk/abc/test_abc.py (original) (raw)

Thu Apr 26 01:37:42 CEST 2007

 """A plain set is a finite, iterable container.
 def __hash__(self):
     """The hash value must match __eq__.
   """Return True if it was added, False if already there."""
   raise NotImplementedError
   """Return True if it was deleted, False if not there."""
   raise NotImplementedError
   """Implementing this would be bad and slow, hence it's abstract."""
   # XXX It's a pain to have to define this.  Maybe leave out?
   raise NotImplementedError
   """Return the popped value.  Raise KeyError if empty."""
   it = iter(self)
   try:
       value = it.__next__()
   except StopIteration:
       raise KeyError
   self.discard(value)
   return value
   """Return True if it was added, False if deleted."""
   # XXX This implementation is not thread-safe
   if value in self:
       self.discard(value)
       return False
   else:
       self.add(value)
       return True
   for value in it:
       self.add(value)
   return self
   for value in self:
       if value not in c:
           self.discard(value)
   return self
   # This calls toggle(), so if that is overridded, we call the override
   for value in it:
       self.toggle(it)
   return self
   for value in it:
       self.discard(value)
   return self
 """A minimal sequence.
   for val in self:
       if val == value:
           return True
   return False
def __reversed__(self):
    i = len(self)
    while i > 0:
 def index(self, value):
   # XXX Should we add optional start/stop args?  Probably not.
   for i, elem in enumerate(self):
       if elem == value:
           return i
def __eq__(self, other):
    if not isinstance(other, Sequence):
        return NotImplemented
   self.assertRaises(abc.AbstractInstantiationError, C)
   self.assertRaises(TypeError, C)
   class D(C):
       def bar(self): pass
   self.assertRaises(abc.AbstractInstantiationError, D)
   self.assertRaises(TypeError, D)
   class E(D):
       def foo(self): pass
   E()

[Python-checkins] r54976 - sandbox/trunk/abc/abc.py sandbox/trunk/abc/test_abc.py (original) (raw)

Modified: sandbox/trunk/abc/abc.py

XXX Should we define ge and gt too?

XXX The following implementations of &, |, ^, - return frozen sets

because we have to pick a concrete type. They are allowed to

return any subclass of Set (but Set is not a

concrete implementation).

XXX The following implementations of &, |, ^, - return frozen

sets because we have to pick a concrete type. They are allowed

to return any subclass of Set (but Set is not a concrete

implementation). We return frozen sets because returning set

may mislead callers from assuming that these operations always

return mutable sets.

XXX Alternatively, we might make these abstract.

class set(Set)

class frozenset(HashableSet)

XXX Do we want all or some of the following?

XXX Should we derive from PartiallyOrdered or TotallyOrdered?

That depends on the items. What if the items aren't orderable?

Modified: sandbox/trunk/abc/test_abc.py