code: def method(self, returns, **parameter_types):
          
          @wrapt.decorator
          def type_check_wrapper(method, instance, args, kwargs):
              """Wraps a method so that it is type-checked.
  
              :param method: The method to wrap
              :type method: (T) -> U
              :return: The result of calling the method with the given parameters
              :rtype: U
              """
              if instance is not None:
                  raise Exception("Instance shouldn't be set.")
  
              parameter_names = inspect.getargspec(method).args  # pylint: disable=deprecated-method
              defaults = inspect.getargspec(method).defaults  # pylint: disable=deprecated-method
              parameters = self._collect_parameters(parameter_names, args, kwargs, defaults)
  
              parameter_checker.check_types(parameters, parameter_types, self._strict_floats)
  
              result = method(*args, **kwargs)
              parameter_checker.check_return_type(result, returns, self._strict_floats)
  
              return result
  
          def register_method(method):
              """Registers a method with its fully qualified name.
  
              :param method: The method to register
              :type method: function
              :return: The original method wrapped into a type-checker
              :rtype: function
              """
              parameter_names = inspect.getargspec(method).args  # pylint: disable=deprecated-method
              parameter_checker.check_type_declaration(parameter_names, parameter_types)
  
              wrapped_method = type_check_wrapper(method, None, None, None)
              fully_qualified_name = "{}.{}".format(method.__module__, method.__name__)
              self.register(fully_qualified_name, wrapped_method,
                            MethodSignature.create(parameter_names, parameter_types, returns))
              return wrapped_method
  
          return register_method
docs: Syntactic sugar for registering a method
  
          Example:
  
              >>> registry = Registry()
              >>> @registry.method(returns=int, x=int, y=int)
              ... def add(x, y):
              ...     return x + y
  
          :param returns: The method's return type
          :type returns: type
          :param parameter_types: The types of the method's parameters
          :type parameter_types: dict[str, type]
  
          .. versionadded:: 0.1.0