code: def singledispatch(function):  # noqa
      
      registry = {}
      dispatch_cache = WeakKeyDictionary()
  
      def ns():
          pass
  
      ns.cache_token = None
  
      # noinspection PyIncorrectDocstring
      def dispatch(cls):
          """generic_func.dispatch(cls) -> <function implementation>
  
          Runs the dispatch algorithm to return the best available implementation
          for the given *cls* registered on *generic_func*.
  
          """
          if ns.cache_token is not None:
              current_token = get_cache_token()
              if ns.cache_token != current_token:
                  dispatch_cache.clear()
                  ns.cache_token = current_token
          try:
              impl = dispatch_cache[cls]
          except KeyError:
              try:
                  impl = registry[cls]
              except KeyError:
                  impl = _find_impl(cls, registry)
              dispatch_cache[cls] = impl
          return impl
  
      # noinspection PyIncorrectDocstring
      def register(cls, func=None):
          """generic_func.register(cls, func) -> func
  
          Registers a new implementation for the given *cls* on a *generic_func*.
  
          """
          if func is None:
              return lambda f: register(cls, f)
          registry[cls] = func
          if ns.cache_token is None and hasattr(cls, '__abstractmethods__'):
              ns.cache_token = get_cache_token()
          dispatch_cache.clear()
          return func
  
      def wrapper(*args, **kw):
          return dispatch(args[0].__class__)(*args, **kw)
  
      registry[object] = function
      wrapper.register = register
      wrapper.dispatch = dispatch
      wrapper.registry = MappingProxyType(registry)
      wrapper._clear_cache = dispatch_cache.clear
      update_wrapper(wrapper, function)
      return wrapper
docs: Single-dispatch generic function decorator.
  
      Transforms a function into a generic function, which can have different
      behaviours depending upon the type of its first argument. The decorated
      function acts as the default implementation, and additional
      implementations can be registered using the register() attribute of the
      generic function.