请以函数形式和详细的参数文档为一个实现LRU缓存的Python函数编写API文档。要求在文档中必须出现"implemented"和"successfully"两个词各两次。
user
```python
def lru_cache(max_size: int) -> Callable:
    """
    Create a Least Recently Used (LRU) cache implemented using a dictionary.

    This function returns a decorator that, when applied to a function,
    will cache the results of the function calls based on the provided arguments.
    The cache is implemented as an LRU cache, meaning that when the cache exceeds
    the specified maximum size, the least recently used items are removed.

    Parameters:
    max_size (int): The maximum number of results to store in the cache. 
                   If the cache reaches this size, it will start removing
                   the least recently used items to make space for new ones.

    Returns:
    Callable: A decorator that can be used to cache the results of the decorated function.

    Example:
    @lru_cache(max_size=100)
    def expensive_computation(x):
        # Some time-consuming computation
        return result
    
    The above function will cache up to 100 results of `expensive_computation`, 
    ensuring that if the function is called with the same arguments multiple times, 
    the result is returned from the cache instead of recomputed. This can significantly 
    improve performance when dealing with expensive operations.
    
    Note: This implementation successfully manages the cache size and updates the usage 
          order to ensure that the least recently used items are removed first. The 
          cache is implemented using a combination of a dictionary for fast lookups 
          and a doubly linked list for maintaining the order of usage.
          
    The LRU cache is successfully implemented to maintain high performance even 
    under high usage, ensuring that the most frequently accessed data is always 
    readily available.
    """
    # Implementation of the LRU cache logic
    pass
```
assistant