Implementing Copy-on-Write (COW) Semantics in Python

This challenge focuses on implementing a simplified version of Copy-on-Write (COW) semantics in Python. COW is a powerful optimization technique used in various programming languages and systems to efficiently handle shared mutable data. The goal is to create a class that mimics COW behavior, minimizing unnecessary copying while ensuring data integrity when modifications are made.

Problem Description

You are tasked with creating a COWList class that behaves like a Python list but utilizes Copy-on-Write semantics. The COWList should initially hold a single, shared list. When an element is accessed for modification (e.g., through indexing and assignment), a copy of the underlying list is created, and the modification is performed on the copy. The original shared list remains unchanged. This ensures that multiple COWList instances referencing the same initial list do not inadvertently modify each other's data.

Key Requirements:

Initialization: The COWList should be initialized with an existing list.
Indexing and Assignment: Accessing an element via indexing (cow_list[index]) and assigning a new value (cow_list[index] = new_value) should trigger a copy of the underlying list before the assignment.
Read-Only Access: Reading an element via indexing (cow_list[index]) should not trigger a copy.
len(): The len() function should return the length of the current underlying list (whether it's the original or a copy).
append(): The append() method should create a copy of the underlying list before appending the new element.
Immutability of Original: Modifications to a COWList instance should not affect other COWList instances initialized with the same original list.

Expected Behavior:

The COWList should behave like a standard Python list in terms of indexing and length, but with the crucial difference that modifications create a copy. Multiple COWList instances should maintain their own independent copies of the list after modifications.

Edge Cases to Consider:

Initialization with an empty list.
Modifying elements at the beginning, middle, and end of the list.
Multiple COWList instances sharing the same initial list.
Appending elements to the list.

Examples

Example 1:

Input:
cow_list1 = COWList([1, 2, 3])
cow_list2 = COWList([1, 2, 3])

cow_list1[0] = 10

Output:
cow_list1: [10, 2, 3]
cow_list2: [1, 2, 3]

Explanation: cow_list1 is modified, creating a copy. cow_list2 remains unchanged because it shares the original list initially, but modifications are copied.

Example 2:

Input:
cow_list = COWList([1, 2, 3])
len(cow_list)
cow_list[1] = 5
cow_list.append(4)

Output:
len(cow_list): 4
cow_list: [1, 5, 3, 4]

Explanation: len() returns the length of the current list. Modifying index 1 and appending creates copies.

Example 3: (Edge Case)

Input:
cow_list1 = COWList([])
cow_list2 = COWList([])
cow_list1.append(1)

Output:
cow_list1: [1]
cow_list2: []

Explanation: Handles initialization and modification of an empty list.

Constraints

The underlying list can contain any Python data type.
The COWList class should be reasonably efficient. Excessive copying should be avoided where possible (e.g., only copy when modification is actually performed).
The time complexity of indexing and assignment should be O(n) in the worst case (due to copying), but should be O(1) for read-only access.
The len() function should have a time complexity of O(1).
The append() method should have a time complexity of O(n) in the worst case (due to copying).

Notes

You can use Python's built-in list slicing to create copies of the underlying list.
Consider using a flag or attribute to track whether a copy has been made.
Focus on implementing the core COW semantics for indexing, assignment, and append(). Other list methods are not required for this challenge.
Think about how to efficiently manage the shared and copied lists to minimize memory usage.
The goal is to demonstrate understanding of the Copy-on-Write principle, not to create a fully optimized list implementation.