== Handling lines with something-separated fields for Python

As a system administrator, I spend a bunch of my time dealing with
files made up of lines that are composed of fields separated by some
character. A classical example is _/etc/passwd_, with colon-separated
fields. These file formats are ordered lists with named fields, which
should [[sound familiar ListsWithNamedFields]], but they don't show
up as Python lists, they show up as lines of text and they want to
be output as text; that we use lists to represent them is just an
implementation detail.

This only takes a little bit of extra work to implement on top of
our previous [[_SetMixin_ class ListsWithNamedFields]]:

 class FieldLine(SetMixin, list):
     separator = ":"
     def __init__(self, line):
         n = line.split(self.separator)
         super(FieldLine, self).__init__(n)
     def __str__(self):
         return self.separator.join(self)
 
 class PasswdLine(FieldLine):
     fields = gen_fields('name', 'passwd',
                         'uid', 'gid', 'gecos',
                         'dir', 'shell')

(Where ((gen_fields)) is basically the dict()-ized version of
((enum_args)) from [[here ListsWithNamedFields]].)

Now that I've written these entries, I have a confession: this is
actually what I started out doing. I didn't first build a general
ordered list with named fields class and then realized it could be used
to deal with _/etc/passwd_ lines; I started out needing to deal with
_/etc/passwd_ lines, decided that I wanted read/write access to named
fields, and then built downwards. I just wrote it up backwards because
it looks neater that way.

(In fact this is the cleaned up and idealized version of this class. The
real one in my program does not subclass _list_; instead it is a normal
class with a private '((field_store))' list and everything just directly
manipulates that. It also doesn't handle the slicing cases, because I
didn't need to. I did the new version for here for various reasons,
including that it was a good excuse to play around with subclassing
built in types.)