Persistent data structures are a method of data structures that retain all of their prior versions so that any access to an antique state could be done without loss of information. Operations don’t change the structure in place; they fabricate new versions and share those parts that have not changed to ensure efficiency. They are available in two kinds: partial persistence and full persistence.

How They Work:

1. Immutability: Modifications create new versions without changing the existing ones.
2. Structural Sharing: New versions can share parts of their structure with old versions so that little is duplicated.
3. Path Copying: In case of tree-structured composition, only the nodes on the path from the modified node to the root need to be copied and everything else may be shared.

Use Cases:

1. Functional Programming: This is an integral approach to languages like Haskell and Clojure, where immutability is practiced above board.
2. Undo Operations: These are quite common in applications like text editors, especially in going back before an edit operation.
3. Version Control Systems: It efficiently navigates all versions of files; structures like Git does version-control.
4. Concurrency Control: Designed to avoid problems introduced into a multi-threaded environment, this allows versions for every thread.
5. Historical Data Analysis: This is useful for financial systems or temporal databases where analysis of the state of past data is necessary.

Persistent data structures make it possible to build efficient, reliable, and scalable software.