docs: def unpack(cls, value, value_type, visitor):
          """Unpack a value during a 'visit'
  
          args:
  
              ``value=``\ *object*
                  The instance being visited
  
              ``value_type=``\ *RecordType*
                  The expected type of the instance
  
              ``visitor=``\ *Visitor*
                  The context/options
  
          returns a tuple with two items:
  
              ``get_prop=``\ *function*
                  This function should take a
                  :py:class:`normalize.property.Property` instance, and return
                  the slot from the value, or raise ``AttributeError`` or
                  ``KeyError`` if the slot is empty.  Returning nothing means
                  that the item has no properties to unpack; ie, it's an opaque
                  type.
  
              ``get_item=``\ *generator*
                  This generator should return the tuple protocol used by
                  :py:class:`normalize.coll.Collection`: (K, V) where K can be an
                  ascending integer (for sequences), V (for sets), or something
                  hashable like a string (for dictionaries/maps)
          """
          if issubclass(value_type, Collection):
              try:
                  generator = value.itertuples()
              except AttributeError:
                  if isinstance(value, value_type.colltype):
                      generator = value_type.coll_to_tuples(value)
                  else:
                      raise exc.VisitorUnpackError(
                          passed=value,
                          colltype=value_type.colltype.__name__,
                          context=visitor,
                      )
          else:
              generator = None
  
          if issubclass(value_type, Record):
              def propget(prop):
                  return prop.__get__(value)
          else:
              propget = None
  
          return propget, generator