docs: def load(self, typedef, value, **kwargs):
          """
          Return the result of the bound load method for a typedef
  
          Looks up the load function that was bound to the engine for a typedef,
          and return the result of passing the given `value` and any `context`
          to that function.
  
          Parameters
          ----------
          typedef : :class:`~TypeDefinition`
              The typedef whose bound load method should be used
          value : object
              The value to be passed into the bound load method
          **kwargs : kwargs
              Context for the value being loaded
  
          Returns
          -------
          loaded_value : object
              The return value of the load function for the input value
  
          Raises
          ------
          exc : :class:`KeyError`
              If the input typedef is not bound to this engine
  
          Example
          -------
  
          .. code-block:: python
  
              class Account(TypeDefinition):
                  prefix = "::account"
                  def load(self, value, **context):
                      return value + Account.prefix
  
                  def dump(self, value, **context):
                      return value[:-len(Account.prefix)]
  
              typedef = Account()
              engine = TypeEngine("accounts")
              engine.register(typedef)
              engine.bind()
              assert engine.dump(typedef, "Jill::account") == "Jill"
  
          """
          try:
              bound_type = self.bound_types[typedef]
          except KeyError:
              raise DeclareException(
                  "Can't load unknown type {}".format(typedef))
          else:
              # Don't need to try/catch since load/dump are bound together
              return bound_type["load"](value, **kwargs)