code: def check(predicate):
      r
  
      def decorator(func):
          if isinstance(func, Command):
              func.checks.append(predicate)
          else:
              if not hasattr(func, '__commands_checks__'):
                  func.__commands_checks__ = []
  
              func.__commands_checks__.append(predicate)
  
          return func
      return decorator
docs: r"""A decorator that adds a check to the :class:`.Command` or its
      subclasses. These checks could be accessed via :attr:`.Command.checks`.
  
      These checks should be predicates that take in a single parameter taking
      a :class:`.Context`. If the check returns a ``False``\-like value then
      during invocation a :exc:`.CheckFailure` exception is raised and sent to
      the :func:`.on_command_error` event.
  
      If an exception should be thrown in the predicate then it should be a
      subclass of :exc:`.CommandError`. Any exception not subclassed from it
      will be propagated while those subclassed will be sent to
      :func:`.on_command_error`.
  
      .. note::
  
          These functions can either be regular functions or coroutines.
  
      Examples
      ---------
  
      Creating a basic check to see if the command invoker is you.
  
      .. code-block:: python3
  
          def check_if_it_is_me(ctx):
              return ctx.message.author.id == 85309593344815104
  
          @bot.command()
          @commands.check(check_if_it_is_me)
          async def only_for_me(ctx):
              await ctx.send('I know you!')
  
      Transforming common checks into its own decorator:
  
      .. code-block:: python3
  
          def is_me():
              def predicate(ctx):
                  return ctx.message.author.id == 85309593344815104
              return commands.check(predicate)
  
          @bot.command()
          @is_me()
          async def only_me(ctx):
              await ctx.send('Only you!')
  
      Parameters
      -----------
      predicate: Callable[:class:`Context`, :class:`bool`]
          The predicate to check if the command should be invoked.