*** empty log message ***

diff --git a/Demo/classes/Complex.py b/Demo/classes/Complex.py
index 5880c64eff1cadfb3c650f007f79dad90fb0892f..b7ba2e0f5ce8421128936a3d3bdeee72278034bb 100755 (executable)
--- a/Demo/classes/Complex.py
+++ b/Demo/classes/Complex.py
@@ -4,16 +4,21 @@
 from math import sqrt
 
 
-def complex(re, im):
-       return Complex().init(re, im)
+class complex:
 
-
-class Complex:
-
-       def init(self, re, im):
+       def __init__(self, re, im):
                self.re = float(re)
                self.im = float(im)
-               return self
+
+       def __coerce__(self, other):
+               if type(other) == type(self):
+                       if other.__class__ == self.__class__:
+                               return self, other
+                       else:
+                               raise TypeError, 'cannot coerce to complex'
+               else:
+                       # The cast to float() may raise an exception!
+                       return self, complex(float(other), 0.0)
 
        def __repr__(self):
                return 'complex' + `self.re, self.im`
@@ -60,9 +65,16 @@ class Complex:
 def test():
        a = complex(2, 0)
        b = complex(3, 4)
-       print a, b
-       print a+b, a-b, a*b, a/b
-       print b+a, b-a, b*a, b/a
+       print a
+       print b
+       print a+b
+       print a-b
+       print a*b
+       print a/b
+       print b+a
+       print b-a
+       print b*a
+       print b/a
        i = complex(0, 1)
        print i, i*i, i*i*i, i*i*i*i
        j = complex(1, 1)

diff --git a/Demo/classes/Dbm.py b/Demo/classes/Dbm.py
index 0bd5491f6733d0a03513bd23ca3cb0099c58e52e..8d7fe0f8f4b282717fb94ece4489e8da5d338275 100755 (executable)
--- a/Demo/classes/Dbm.py
+++ b/Demo/classes/Dbm.py
@@ -41,11 +41,11 @@ class Dbm:
 
 
 def test():
-       d = Dbm('@dbm', 'rw', 0666)
+       d = Dbm('@dbm', 'rw', 0600)
        print d
        while 1:
                try:
-                       key = eval(raw_input('key: '))
+                       key = input('key: ')
                        if d.has_key(key):
                                value = d[key]
                                print 'currently:', value

diff --git a/Demo/classes/README b/Demo/classes/README
index f821f78818febf52320b44de4a79eaa551477cc0..cca75248919319c442e43252773fe277ae819856 100644 (file)
--- a/Demo/classes/README
+++ b/Demo/classes/README
@@ -1,4 +1,4 @@
-Examples of classes that implement special operators (see class.doc):
+Examples of classes that implement special operators (see reference manual):
 
 Complex.py     Complex numbers
 Dates.py       Date manipulation package by Tim Peters

diff --git a/Demo/classes/Range.py b/Demo/classes/Range.py
index b8bc9beef38a8d5097568aa965f6bebf5597e825..e7b6be2c7a8e8019d759fc0e721e6dcd40738e78 100755 (executable)
--- a/Demo/classes/Range.py
+++ b/Demo/classes/Range.py
@@ -16,7 +16,7 @@ def range(*a):
                start, stop, step = a
        else:
                raise TypeError, 'range() needs 1-3 arguments'
-       return Range().init(start, stop, step)
+       return Range(start, stop, step)
        
 
 # Class implementing a range object.
@@ -26,14 +26,13 @@ def range(*a):
 class Range:
 
        # initialization -- should be called only by range() above
-       def init(self, start, stop, step):
+       def __init__(self, start, stop, step):
                if step == 0:
                        raise ValueError, 'range() called with zero step'
                self.start = start
                self.stop = stop
                self.step = step
                self.len = max(0, int((self.stop - self.start) / self.step))
-               return self
 
        # implement `x` and is also used by print x
        def __repr__(self):

diff --git a/Demo/classes/Rat.py b/Demo/classes/Rat.py
index 0d3e5156133c72806daf28d4045f41e2761069b5..d10e4dfac43dd961893d25e4b0839931509b5d61 100755 (executable)
--- a/Demo/classes/Rat.py
+++ b/Demo/classes/Rat.py
@@ -2,7 +2,7 @@
 
 
 def rat(num, den):
-       return Rat().init(num, den)
+       return Rat(num, den)
 
 
 def gcd(a, b):
@@ -13,13 +13,12 @@ def gcd(a, b):
 
 class Rat:
 
-       def init(self, num, den):
+       def __init__(self, num, den):
                if den == 0:
                        raise ZeroDivisionError, 'rat(x, 0)'
                g = gcd(num, den)
                self.num = num/g
                self.den = den/g
-               return self
 
        def __repr__(self):
                return 'rat' + `self.num, self.den`
@@ -49,8 +48,10 @@ class Rat:
                        return a, rat(b, 1L)
                if t == type(0.0):
                        return a.__float__(), b
+               if t == type(a) and a.__class__ == b.__class__:
+                       return a, b
                raise TypeError, 'Rat.__coerce__: bad other arg'
-                       
+
        def __add__(a, b):
                if type(b) <> type(a):
                        a, b = a.__coerce__(b)
@@ -93,4 +94,4 @@ def test():
        except ZeroDivisionError:
                print 'OK'
 
-#test()
+test()

diff --git a/Demo/classes/Rev.py b/Demo/classes/Rev.py
index 5cf4602a8ac9abffca40742c44ea955f86bdd4f3..c1874c65c5c51ff99652c791bf521611303f8b01 100755 (executable)
--- a/Demo/classes/Rev.py
+++ b/Demo/classes/Rev.py
@@ -8,7 +8,7 @@
 # ... 
 # !dlroW olleH
 #
-# The .forw is so you can use anonymous sequences in init, and still
+# The .forw is so you can use anonymous sequences in __init__, and still
 # keep a reference the forward sequence. ) 
 # If you give it a non-anonymous mutable sequence, the reverse sequence
 # will track the updated values. ( but not reassignment! - another 

diff --git a/Demo/classes/Vec.py b/Demo/classes/Vec.py
index 6e2bc4734ce65bfb2794de316c16c45e372596d4..8289bc847e0d5c19a046f915442460c53e647b95 100755 (executable)
--- a/Demo/classes/Vec.py
+++ b/Demo/classes/Vec.py
@@ -2,16 +2,15 @@
 
 
 def vec(*v):
-       return apply(Vec().init, v)
+       return apply(Vec, v)
 
 
 class Vec:
 
-       def init(self, *v):
+       def __init__(self, *v):
                self.v = []
                for x in v:
                        self.v.append(x)
-               return self
 
 
        def fromlist(self, v):

diff --git a/Demo/classes/bitvec.py b/Demo/classes/bitvec.py
index 40cd13ff781d6fce712986c8e2acaad2ecce1a17..69718d7a3eca748a4e21f5c4dde588a2e5b99f49 100755 (executable)
--- a/Demo/classes/bitvec.py
+++ b/Demo/classes/bitvec.py
@@ -48,7 +48,7 @@ def _check_slice(len, i, j):
 
 class BitVec:
 
-       def init(self, *params):
+       def __init__(self, *params):
                self._data = 0L
                self._len = 0
                if not len(params):
@@ -93,20 +93,12 @@ class BitVec:
                else:
                        raise error, 'bitvec() requires 0 -- 2 parameter(s)'
 
-               return self
-
-
-       def _init(self, data, len):
-               self._data = data
-               self._len = len
-               return self
-
                
        def append(self, item):
                #_check_value(item)
                #self[self._len:self._len] = [item]
                self[self._len:self._len] = \
-                         BitVec()._init(long(not not item), 1)
+                         BitVec(long(not not item), 1)
 
                
        def count(self, value):
@@ -138,7 +130,7 @@ class BitVec:
        def insert(self, index, item):
                #_check_value(item)
                #self[index:index] = [item]
-               self[index:index] = BitVec()._init(long(not not item), 1)
+               self[index:index] = BitVec(long(not not item), 1)
 
 
        def remove(self, value):
@@ -163,7 +155,7 @@ class BitVec:
 
 
        def copy(self):
-               return BitVec()._init(self._data, self._len)
+               return BitVec(self._data, self._len)
 
 
        def seq(self):
@@ -229,7 +221,7 @@ class BitVec:
                #rprt(`self`+'.__getslice__'+`i, j`+'\n')
                i, j = _check_slice(self._len, i, j)
                if i >= j:
-                       return BitVec()._init(0L, 0)
+                       return BitVec(0L, 0)
                if i:
                        ndata = self._data >> i
                else:
@@ -239,7 +231,7 @@ class BitVec:
                        #we'll have to invent faster variants here
                        #e.g. mod_2exp
                        ndata = ndata & ((1L << nlength) - 1)
-               return BitVec()._init(ndata, nlength)
+               return BitVec(ndata, nlength)
 
        def __setslice__(self, i, j, sequence, *rest):
                #rprt(`self`+'.__setslice__'+`(i, j, sequence) + rest`+'\n')
@@ -274,16 +266,16 @@ class BitVec:
                if type(multiplier) != type(0):
                        raise TypeError, 'sequence subscript not int'
                if multiplier <= 0:
-                       return BitVec()._init(0L, 0)
+                       return BitVec(0L, 0)
                elif multiplier == 1:
                        return self.copy()
                #handle special cases all 0 or all 1...
                if self._data == 0L:
-                       return BitVec()._init(0L, self._len * multiplier)
+                       return BitVec(0L, self._len * multiplier)
                elif (~self)._data == 0L:
-                       return ~BitVec()._init(0L, self._len * multiplier)
+                       return ~BitVec(0L, self._len * multiplier)
                #otherwise el cheapo again...
-               retval = BitVec()._init(0L, 0)
+               retval = BitVec(0L, 0)
                while multiplier:
                        retval, multiplier = retval + self, multiplier - 1
                return retval
@@ -293,7 +285,7 @@ class BitVec:
                if type(otherseq) != type(self):
                        otherseq = apply(bitvec, (otherseq, ) + rest)
                #sequence is now of our own type
-               return BitVec()._init(self._data & otherseq._data, \
+               return BitVec(self._data & otherseq._data, \
                          min(self._len, otherseq._len))
 
 
@@ -302,7 +294,7 @@ class BitVec:
                if type(otherseq) != type(self):
                        otherseq = apply(bitvec, (otherseq, ) + rest)
                #sequence is now of our own type
-               return BitVec()._init(self._data ^ otherseq._data, \
+               return BitVec(self._data ^ otherseq._data, \
                          max(self._len, otherseq._len))
 
 
@@ -311,13 +303,13 @@ class BitVec:
                if type(otherseq) != type(self):
                        otherseq = apply(bitvec, (otherseq, ) + rest)
                #sequence is now of our own type
-               return BitVec()._init(self._data | otherseq._data, \
+               return BitVec(self._data | otherseq._data, \
                          max(self._len, otherseq._len))
 
 
        def __invert__(self):
                #rprt(`self`+'.__invert__()\n')
-               return BitVec()._init(~self._data & ((1L << self._len) - 1), \
+               return BitVec(~self._data & ((1L << self._len) - 1), \
                          self._len)
 
        def __coerce__(self, otherseq, *rest):
@@ -337,5 +329,4 @@ class BitVec:
                return float(self._data)
 
 
-def bitvec(params):
-       return apply(BitVec().init, params)
+bitvec = BitVec