def diff(target, sub, *, path_=None) -> bool:
    """Simple recursive asymmetric diff function on json-like data structures.

    Args:
        target: The data container in which we want to find a subtree.
        sub: The subtree that needs to be matched.
        path_: A private object used to produce meaningful error messages.

    Returns:
        True if the subtree could be cleanly matched, else False.

    Raises:
        TypeError: If the parse paths don't match, e.g. the target is a list
            at a level where the subtree expected it to be a dictionary.
    """
    if path_ is None:
        path_ = ["root"]

    if type(target) != type(sub):
        raise TypeError(f"Types of target '{type(target)}' and sub '{type(sub)}' are incompatible at junction {path_}.")

    if isinstance(sub, list):
        for n, s_elem in enumerate(sub):
            for t_elem in target:
                if diff(t_elem, s_elem, path_=[*path_, n]):
                    break
            else:
                return False
        return True
    elif isinstance(sub, dict):
        for s_key in sub:
            if s_key in target and diff(target[s_key], sub[s_key], path_=[*path_, s_key]):
                continue
            return False
        return True
    else:  # some kind of leaf, i.e. string, int, bool, float, or None
        return bool(target == sub)