docs: def overloaded(func):
      """
      Introduces a new overloaded function and registers its first implementation.
      """
      fn = unwrap(func)
      ensure_function(fn)
  
      def dispatcher(*args, **kwargs):
  
          resolved = None
          if dispatcher.__complex_parameters:
              cache_key_pos = []
              cache_key_kw = []
              for argset in (0, 1) if kwargs else (0,):
                  if argset == 0:
                      arg_pairs = enumerate(args)
                      complexity_mapping = dispatcher.__complex_positions
                  else:
                      arg_pairs = kwargs.items()
                      complexity_mapping = dispatcher.__complex_parameters
                  for id, arg in arg_pairs:
                      type_ = type(arg)
                      element_type = None
                      if id in complexity_mapping:
                          try:
                              element = next(iter(arg))
                          except TypeError:
                              pass
                          except StopIteration:
                              element_type = _empty
                          else:
                              complexity = complexity_mapping[id]
                              if complexity & 8 and isinstance(arg, tuple):
                                  element_type = tuple(type(el) for el in arg)
                              elif complexity & 4 and hasattr(arg, 'keys'):
                                  element_type = (type(element), type(arg[element]))
                              else:
                                  element_type = type(element)
                      if argset == 0:
                          cache_key_pos.append((type_, element_type))
                      else:
                          cache_key_kw.append((id, type_, element_type))
          else:
              cache_key_pos = (type(arg) for arg in args)
              cache_key_kw = ((name, type(arg)) for (name, arg) in kwargs.items()) if kwargs else None
  
          cache_key = (tuple(cache_key_pos),
                       tuple(sorted(cache_key_kw)) if kwargs else None)
  
          try:
              resolved = dispatcher.__cache[cache_key]
          except KeyError:
              resolved = find(dispatcher, args, kwargs)
              if resolved:
                  dispatcher.__cache[cache_key] = resolved
          if resolved:
              before = dispatcher.__hooks['before']
              after = dispatcher.__hooks['after']
              if before:
                  before(*args, **kwargs)
              result = resolved(*args, **kwargs)
              if after:
                  after(*args, **kwargs)
              return result
          else:
              return error(dispatcher.__name__)
  
      dispatcher.__dict__.update(
          __functions = [],
          __hooks = {'before': None, 'after': None},
          __cache = {},
          __complex_positions = {},
          __complex_parameters = {},
          __maxlen = 0,
      )
      for attr in ('__module__', '__name__', '__qualname__', '__doc__'):
          setattr(dispatcher, attr, getattr(fn, attr, None))
      if is_void(fn):
          update_docstring(dispatcher, fn)
          return dispatcher
      else:
          update_docstring(dispatcher)
          return register(dispatcher, func)