--- rest25/library/shelve.rst	2008-12-19 16:58:07.000000000 +0900
+++ rest262/library/shelve.rst	2009-04-07 00:06:53.000000000 +0900
@@ -6,25 +6,25 @@
    :synopsis: Python object persistence.
 
 
 .. index:: module: pickle
 
 A "shelf" is a persistent, dictionary-like object.  The difference with "dbm"
 databases is that the values (not the keys!) in a shelf can be essentially
 arbitrary Python objects --- anything that the :mod:`pickle` module can handle.
 This includes most class instances, recursive data types, and objects containing
 lots of shared  sub-objects.  The keys are ordinary strings.
 
 
-.. function:: open(filename[,flag='c'[,protocol=``None``[,writeback=``False``]]])
+.. function:: open(filename[, flag='c'[, protocol=None[, writeback=False]]])
 
    Open a persistent dictionary.  The filename specified is the base filename for
    the underlying database.  As a side-effect, an extension may be added to the
    filename and more than one file may be created.  By default, the underlying
    database file is opened for reading and writing.  The optional *flag* parameter
    has the same interpretation as the *flag* parameter of :func:`anydbm.open`.
 
    By default, version 0 pickles are used to serialize values.  The version of the
    pickle protocol can be specified with the *protocol* parameter.
 
    .. versionchanged:: 2.3
       The *protocol* parameter was added.
@@ -42,24 +42,30 @@
 transition from dictionary based scripts to those requiring persistent storage.
 
 One additional method is supported:
 
 
 .. method:: Shelf.sync()
 
    Write back all entries in the cache if the shelf was opened with *writeback* set
    to *True*. Also empty the cache and synchronize the persistent dictionary on
    disk, if feasible.  This is called automatically when the shelf is closed with
    :meth:`close`.
 
+.. seealso::
+
+   `Persistent dictionary recipe <http://code.activestate.com/recipes/576642/>`_
+   with widely supported storage formats and having the speed of native
+   dictionaries.
+
 
 Restrictions
 ------------
 
   .. index::
      module: dbm
      module: gdbm
      module: bsddb
 
 * The choice of which database package will be used (such as :mod:`dbm`,
   :mod:`gdbm` or :mod:`bsddb`) depends on which interface is available.  Therefore
   it is not safe to open the database directly using :mod:`dbm`.  The database is
@@ -133,25 +139,25 @@
 
    d[key] = data   # store data at key (overwrites old data if
                    # using an existing key)
    data = d[key]   # retrieve a COPY of data at key (raise KeyError if no
                    # such key)
    del d[key]      # delete data stored at key (raises KeyError
                    # if no such key)
    flag = d.has_key(key)   # true if the key exists
    klist = d.keys() # a list of all existing keys (slow!)
 
    # as d was opened WITHOUT writeback=True, beware:
    d['xx'] = range(4)  # this works as expected, but...
-   d['xx'].append(5)   # *this doesn't!* -- d['xx'] is STILL range(4)!!!
+   d['xx'].append(5)   # *this doesn't!* -- d['xx'] is STILL range(4)!
 
    # having opened d without writeback=True, you need to code carefully:
    temp = d['xx']      # extracts the copy
    temp.append(5)      # mutates the copy
    d['xx'] = temp      # stores the copy right back, to persist it
 
    # or, d=shelve.open(filename,writeback=True) would let you just code
    # d['xx'].append(5) and have it work as expected, BUT it would also
    # consume more memory and make the d.close() operation slower.
 
    d.close()       # close it
 
