def keep_types(self, base_key, out_key, *types):
        """
        Method to keep only specific parameters from a parameter documentation.

        This method extracts the given `type` from the `base_key` item in the
        :attr:`params` dictionary and creates a new item with the original
        documentation with only the description of the type. This method works
        for the ``'Results'`` sections.

        Parameters
        ----------
        base_key: str
            key in the :attr:`params` dictionary
        out_key: str
            Extension for the base key (the final key will be like
            ``'%s.%s' % (base_key, out_key)``
        ``*types``
            str. The type identifier of which the documentations shall be
            in the new section

        See Also
        --------
        delete_types, keep_params

        Examples
        --------
        To extract just two return arguments from a function and reuse their
        docstrings, you can type::

            >>> from docrep import DocstringProcessor
            >>> d = DocstringProcessor()
            >>> @d.get_sectionsf('do_something', sections=['Returns'])
            ... def do_something():
            ...     '''
            ...     That's %(doc_key)s
            ...
            ...     Returns
            ...     -------
            ...     float
            ...         A random number
            ...     int
            ...         A random integer'''
            ...     return 1.0, 4

            >>> d.keep_types('do_something.returns', 'int_only', 'int')

            >>> @d.dedent
            ... def do_less():
            ...     '''
            ...     My second function that only returns an integer
            ...
            ...     Returns
            ...     -------
            ...     %(do_something.returns.int_only)s'''
            ...     return do_something()[1]

            >>> print(do_less.__doc__)
            My second function that only returns an integer
            <BLANKLINE>
            Returns
            -------
            int
                A random integer

        Equivalently, you can use the :meth:`delete_types` method to remove
        parameters::

            >>> d.delete_types('do_something.returns', 'no_float', 'float')

            >>> @d.dedent
            ... def do_less():
            ...     '''
            ...     My second function with only `a` and `c`
            ...
            ...     Returns
            ...     ----------
            ...     %(do_something.returns.no_float)s'''
            ...     return do_something()[1]
        """
        self.params['%s.%s' % (base_key, out_key)] = self.keep_types_s(
            self.params[base_key], types)