pre-PEP: Simple Thunks

[Brian Sabbey]

Ron_Adam wrote:
> The load and dump would be private to the data class object. Here's a
> more complete example.
>
> import pickle
> class PickledData(object):
> 	def __init__(self, filename):
> 		self.filename = filename
> 		self.L = None
> 		try:
> 			self._load()
> 		except IOError:
> 			self.L = []
> 	def _load(self):
> 		f = open(self.filename, 'r')
> 		self.L = pickle.load(f)
> 		f.close()
> 	def _update(self):
> 		f = open(self.filename, 'w')
> 		pickle.dump(self.L, f)
> 		f.close()
> 	def append(self, record):
> 		self.L.append(record)
> 		self._update()
> 	# add other methods as needed ie.. get, sort, clear, etc...
>
> pdata = PickledData('filename')
>
> pdata.append('more data')
> pdata.append('even more data')
>
> print pdata.L
> ['more data', 'even more data']
>
>
>> This has the same issues as with opening and closing files:  losing the
>> 'dump', having to always use try/finally if needed, accidentally
>> re-binding 'p', significantly more lines.  Moreover, class 'Pickled' won't
>> be as readable as the 'pickled_file' function above since 'load' and
>> 'dump' are separate methods that share data through 'self'.
>
> A few more lines to create the class, but it encapsulates the data
> object better. It is also reusable and extendable.

This class isn't reusable in the case that one wants to pickle something 
other than an array.  Every type of object that one would wish to pickle 
would require its own class.

Also, this implementation behaves differently because the object is 
re-pickled after every modification.  This could be a problem when writing 
over a network, or to a shared resource.

-Brian