def METHOD_NAME(
    current: Iterable[Current],
    desired: Iterable[Desired],
    current_key: Callable[[Current], Key] = _default_key,
    desired_key: Callable[[Desired], Key] = _default_key,
    equal: Callable[[Current, Desired], bool] = _default_equal,
) -> DiffResult[Current, Desired, Key]:
    """
    Compare two iterables and return a `DiffResult` instance containing the differences between them.
    :param current: The current iterable to compare.
    :type current: Iterable[Current]
    :param desired: The desired iterable to compare.
    :type desired: Iterable[Desired]
    :param current_key: A function that returns the key for an element in the `current` iterable.
        If not provided, the default behavior is to use the element itself as the key.
    :type current_key: Callable[[Current], Key]
    :param desired_key: A function that returns the key for an element in the `desired` iterable.
        If not provided, the default behavior is to use the element itself as the key.
    :type desired_key: Callable[[Desired], Key]
    :param equal: A function that compares two elements in the iterables and returns True if they are equal.
        If not provided, the default behavior is to use the `==` operator.
    :type equal: Callable[[Current, Desired], bool]
    :return: A `DiffResult` instance containing the differences between the `current` and `desired` iterables,
        including elements that were added, deleted, changed or identical.
    :rtype: DiffResult[Current, Desired, Key]
    :raises: None
    Example:
        >>> current = [
        ...     {"name": "i", "value": 1},
        ...     {"name": "c", "value": 2},
        ...     {"name": "d", "value": 3},
        ... ]
        >>> desired = [
        ...     {"name": "i", "value": 1},
        ...     {"name": "c", "value": 20},
        ...     {"name": "a", "value": 30},
        ... ]
        >>> result = diff_any_iterables(
        ...     current,
        ...     desired,
        ...     lambda c: c["name"],
        ...     lambda d: d["name"],
        ...     equal=lambda c, d: c["value"] == d["value"],
        ... )
        DiffResult(
            add={'a': {'name': 'a', 'value': 30}},
            delete={'d': {'name': 'd', 'value': 3}},
            change={'c': DiffPair(current={'name': 'c', 'value': 2}, desired={'name': 'c', 'value': 20})),
            identical={'i': DiffPair(current={'name': 'i', 'value': 1}, desired={'name': 'i', 'value': 1})},
        )
    """
    current_dict = {current_key(c): c for c in current}
    desired_dict = {desired_key(d): d for d in desired}
    return diff_mappings(
        current_dict,
        desired_dict,
        equal=equal,
    )