diff --git a/Demo/classes/Complex.py b/Demo/classes/Complex.py
new file mode 100755
index 0000000..5880c64
--- /dev/null
+++ b/Demo/classes/Complex.py
@@ -0,0 +1,73 @@
+# Complex numbers
+
+
+from math import sqrt
+
+
+def complex(re, im):
+	return Complex().init(re, im)
+
+
+class Complex:
+
+	def init(self, re, im):
+		self.re = float(re)
+		self.im = float(im)
+		return self
+
+	def __repr__(self):
+		return 'complex' + `self.re, self.im`
+
+	def __cmp__(a, b):
+		a = a.__abs__()
+		b = b.__abs__()
+		return (a > b) - (a < b)
+
+	def __float__(self):
+		if self.im:
+			raise ValueError, 'cannot convert complex to float'
+		return float(self.re)
+
+	def __long__(self):
+		return long(float(self))
+
+	def __int__(self):
+		return int(float(self))
+
+	def __abs__(self):
+		# XXX overflow?
+		return sqrt(self.re*self.re + self.im*self.im)
+
+	def __add__(a, b):
+		return complex(a.re + b.re, a.im + b.im)
+
+	def __sub__(a, b):
+		return complex(a.re - b.re, a.im - b.im)
+
+	def __mul__(a, b):
+		return complex(a.re*b.re - a.im*b.im, a.re*b.im + a.im*b.re)
+
+	def __div__(a, b):
+		q = (b.re*b.re + b.im*b.im)
+		re = (a.re*b.re + a.im*b.im) / q
+		im = (a.im*b.re - b.im*a.re) / q
+		return complex(re, im)
+
+	def __neg__(self):
+		return complex(-self.re, -self.im)
+
+
+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
+	i = complex(0, 1)
+	print i, i*i, i*i*i, i*i*i*i
+	j = complex(1, 1)
+	print j, j*j, j*j*j, j*j*j*j
+	print abs(j), abs(j*j), abs(j*j*j), abs(j*j*j*j)
+	print i/-i
+
+test()
diff --git a/Demo/classes/Dbm.py b/Demo/classes/Dbm.py
new file mode 100755
index 0000000..8fccb6a
--- /dev/null
+++ b/Demo/classes/Dbm.py
@@ -0,0 +1,71 @@
+# A wrapper around the (optional) built-in class dbm, supporting keys
+# and values of almost any type instead of just string.
+# (Actually, this works only for keys and values that can be read back
+# correctly after being converted to a string.)
+
+
+def opendbm(filename, mode, perm):
+	return Dbm().init(filename, mode, perm)
+
+
+class Dbm:
+
+	def init(self, filename, mode, perm):
+		import dbm
+		self.db = dbm.open(filename, mode, perm)
+		return self
+
+	def __repr__(self):
+		s = ''
+		for key in self.keys():
+			t = `key` + ': ' + `self[key]`
+			if s: t = t + ', '
+			s = s + t
+		return '{' + s + '}'
+
+	def __len__(self):
+		return len(self.db)
+
+	def __getitem__(self, key):
+		return eval(self.db[`key`])
+
+	def __setitem__(self, key, value):
+		self.db[`key`] = `value`
+
+	def __delitem__(self, key):
+		del self.db[`key`]
+
+	def keys(self):
+		res = []
+		for key in self.db.keys():
+			res.append(eval(key))
+		return res
+
+	def has_key(self, key):
+		return self.db.has_key(`key`)
+
+
+def test():
+	d = opendbm('@dbm', 'rw', 0666)
+	print d
+	while 1:
+		try:
+			key = eval(raw_input('key: '))
+			if d.has_key(key):
+				value = d[key]
+				print 'currently:', value
+			value = eval(raw_input('value: '))
+			if value == None:
+				del d[key]
+			else:
+				d[key] = value
+		except KeyboardInterrupt:
+			print ''
+			print d
+		except EOFError:
+			print '[eof]'
+			break
+	print d
+
+
+test()
diff --git a/Demo/classes/README b/Demo/classes/README
new file mode 100644
index 0000000..c10001f
--- /dev/null
+++ b/Demo/classes/README
@@ -0,0 +1,11 @@
+Examples of classes that implement special operators (see class.doc):
+
+Complex.py	Complex numbers
+Dbm.py		Wrapper around built-in dbm, supporting	arbitrary values
+Range.py	Example of a generator: re-implement built-in range()
+Rat.py		Rational numbers
+Vec.py		A simple vector class
+
+(For straightforward examples of basic class features, such as use of
+methods and inheritance, see the library code -- especially the window
+modules are full of them.)
diff --git a/Demo/classes/Range.py b/Demo/classes/Range.py
new file mode 100755
index 0000000..b8bc9be
--- /dev/null
+++ b/Demo/classes/Range.py
@@ -0,0 +1,72 @@
+# Example of a generator: re-implement the built-in range function
+# without actually constructing the list of values.  (It turns out
+# that the built-in function is about 20 times faster -- that's why
+# it's built-in. :-)
+
+
+# Wrapper function to emulate the complicated range() arguments
+
+def range(*a):
+	if len(a) == 1:
+		start, stop, step = 0, a[0], 1
+	elif len(a) == 2:
+		start, stop = a
+		step = 1
+	elif len(a) == 3:
+		start, stop, step = a
+	else:
+		raise TypeError, 'range() needs 1-3 arguments'
+	return Range().init(start, stop, step)
+	
+
+# Class implementing a range object.
+# To the user the instances feel like immutable sequences
+# (and you can't concatenate or slice them)
+
+class Range:
+
+	# initialization -- should be called only by range() above
+	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):
+		return 'range' + `self.start, self.stop, self.step`
+
+	# implement len(x)
+	def __len__(self):
+		return self.len
+
+	# implement x[i]
+	def __getitem__(self, i):
+		if 0 <= i < self.len:
+			return self.start + self.step * i
+		else:
+			raise IndexError, 'range[i] index out of range'
+
+
+# Small test program
+
+def test():
+	import time, builtin
+	print range(10), range(-10, 10), range(0, 10, 2)
+	for i in range(100, -100, -10): print i,
+	print
+	t1 = time.millitimer()
+	for i in range(1000):
+		pass
+	t2 = time.millitimer()
+	for i in builtin.range(1000):
+		pass
+	t3 = time.millitimer()
+	print t2-t1, 'msec (class)'
+	print t3-t2, 'msec (built-in)'
+
+
+test()
diff --git a/Demo/classes/Rat.py b/Demo/classes/Rat.py
new file mode 100755
index 0000000..0b2519d
--- /dev/null
+++ b/Demo/classes/Rat.py
@@ -0,0 +1,86 @@
+# Rational numbers
+
+
+def rat(num, den):
+	return Rat().init(num, den)
+
+
+def gcd(a, b):
+	while b:
+		a, b = b, a%b
+	return a
+
+
+class Rat:
+
+	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`
+
+	def __cmp__(a, b):
+		c = a-b
+		if c.num < 0:
+			return -1
+		if c.num > 0:
+			return 1
+		return 0
+
+	def __float__(self):
+		return float(self.num) / float(self.den)
+
+	def __long__(self):
+		return long(self.num) / long(self.den)
+
+	def __int__(self):
+		return int(self.num / self.den)
+
+	def __coerce__(a, b):
+		t = type(b)
+		if t == type(0):
+			return a, rat(b, 1)
+		if t == type(0L):
+			return a, rat(b, 1L)
+		if t == type(0.0):
+			return a.__float__(), b
+		raise TypeError, 'Rat.__coerce__: bad other arg'
+			
+	def __add__(a, b):
+		return rat(a.num*b.den + b.num*a.den, a.den*b.den)
+
+	def __sub__(a, b):
+		return rat(a.num*b.den - b.num*a.den, a.den*b.den)
+
+	def __mul__(a, b):
+		return rat(a.num*b.num, a.den*b.den)
+
+	def __div__(a, b):
+		return rat(a.num*b.den, a.den*b.num)
+
+	def __neg__(self):
+		return rat(-self.num, self.den)
+
+
+def test():
+	print rat(-1L, 1)
+	print rat(1, -1)
+	a = rat(1, 10)
+	print int(a), long(a), float(a)
+	b = rat(2, 5)
+	l = [a+b, a-b, a*b, a/b]
+	print l
+	l.sort()
+	print l
+	print rat(0, 1)
+	print rat(1, 0)
+	print a+1
+	print a+1L
+	print a+1.0
+
+test()
diff --git a/Demo/classes/Vec.py b/Demo/classes/Vec.py
new file mode 100755
index 0000000..6e2bc47
--- /dev/null
+++ b/Demo/classes/Vec.py
@@ -0,0 +1,65 @@
+# A simple vector class
+
+
+def vec(*v):
+	return apply(Vec().init, v)
+
+
+class Vec:
+
+	def init(self, *v):
+		self.v = []
+		for x in v:
+			self.v.append(x)
+		return self
+
+
+	def fromlist(self, v):
+		self.v = []
+		if type(v) <> type([]):
+			raise TypeError
+		self.v = v[:]
+		return self
+
+
+	def __repr__(self):
+		return 'vec(' + `self.v`[1:-1] + ')'
+
+	def __len__(self):
+		return len(self.v)
+
+	def __getitem__(self, i):
+		return self.v[i]
+
+	def __add__(a, b):
+		# Element-wise addition
+		v = []
+		for i in range(len(a)):
+			v.append(a[i] + b[i])
+		return Vec().fromlist(v)
+
+	def __sub__(a, b):
+		# Element-wise subtraction
+		v = []
+		for i in range(len(a)):
+			v.append(a[i] - b[i])
+		return Vec().fromlist(v)
+
+	def __mul__(self, scalar):
+		# Multiply by scalar
+		v = []
+		for i in range(len(self.v)):
+			v.append(self.v[i]*scalar)
+		return Vec().fromlist(v)
+
+
+
+def test():
+	a = vec(1, 2, 3)
+	b = vec(3, 2, 1)
+	print a
+	print b
+	print a+b
+	print a*3.0
+
+test()
diff --git a/Demo/classes/class.doc b/Demo/classes/class.doc
new file mode 100755
index 0000000..fddc60b
--- /dev/null
+++ b/Demo/classes/class.doc
@@ -0,0 +1,110 @@
+New features of classes
+=======================
+
+A class can implement certain operations that are invoked by special
+syntax (such as subscription or arithmetic operations) by defining
+methods with special names.
+
+
+Special methods for any type
+----------------------------
+
+__repr__(self) --> string
+
+Used by the print statement and conversions (reverse quotes) to
+compute the string representation of an object.
+
+__cmp__(self, other) --> int
+
+Used by all comparison operations.  Should return -1 if self<other, 0
+if self==other, +1 if self>other.  Due to limitations in the
+interpreter, exceptions raised by comparisons are ignored, and the
+objects will be considered equal in this case.
+
+
+Special methods for sequence and mapping types
+----------------------------------------------
+
+__len__(self) --> int
+
+Used by the built-in function len().  Should return the length of the
+object, which should be >= 0.  Also, an object whose __len__() method
+returns 0 
+
+__getitem__(self, key) --> value
+
+Used to implement value = self[key].  Note that the special
+interpretation of negative keys (if the class wishes to emulate a
+sequence type) is up to the __getitem__ method.
+
+__setitem__(self, key, value)
+
+Used to implement self[key] = value.  Same note as for __getitem__.
+
+__delitem__(self, key)
+
+Used to implement del self[key].  Same note as for __getitem__.
+
+
+Special methods for sequence types
+----------------------------------
+
+__getslice__(self, i, j) --> sequence
+
+Used to implement self[i:j].  Note that missing i or j are replaced by
+0 or len(self), respectively, and len(self) has been added to negative
+i or j.
+
+__setslice__(self, i, j, sequence)
+
+Used to implement self[i:j] = value.  Same note as for __getslice__.
+
+__delslice__(self, i, j)
+
+Used to implement del self[i:j].  Same note as for __getslice__.
+
+
+Special methods for numeric types
+---------------------------------
+
+__add__, __sub__, __mul__, __div__, __mod__, __divmod__, __pow__,
+__lshift__, __rshift__, __and__, __xor__, __or__
+
+Used to implement the binary arithmetic operations (divmod and pow are
+called by built-in functions).  All have the call pattern
+func(self, other) --> number.
+
+__neg__, __pos__, __abs__, __invert__
+
+Used to implement the unary arithmetic operations (-, +, abs and ~).
+All have the call pattern func(self) --> number.
+
+__nonzero__(self) --> int
+
+Used to implement boolean testing.  An alternative name for this
+method is __len__.
+
+__coerce__(self, other) --> (self1, other1) or None
+
+Used to implement "mixed-mode" numeric arithmetic.  Either return a
+tuple containing self and other converted to some common type, or None
+if no way of conversion is known.  When the common type would be the
+type of other, it is sufficient to return None, since the interpreter
+will also ask the other object to attempt a coercion (but sometimes,
+if the implementation of the other type cannot be changed, it is
+useful to do the conversion to the other type here).
+
+__int__(self) --> int
+__long__(self) --> long
+__float__(self) --> float
+
+Used to implement the built-in functions int(), long() and float().
+
+
+Notes
+-----
+
+Except for __repr__ and __cmp__, when no appropriate method is
+defined, attempts to execute the operation raise an exception.  For
+__repr__ and __cmp__, the traditional interpretations are used
+in this case.