Functional programming languages should be better at mutation than they are

Functional programming languages often emphasize avoiding mutation, but this perspective may overlook the necessity of mutation in certain data structures. For instance, structures like union-find require mutation for efficiency, and persistent data structures can introduce significant overhead compared to mutable arrays. The article discusses various approaches to integrating mutation into functional programming without compromising its principles.

One option is to allow unrestricted mutable data structures, which can lead to accidental side effects, undermining the benefits of functional programming. Another approach is to permit mutation only in specific contexts, such as IO, which can help manage side effects but complicates function types. A third method involves local mutation, where mutable state is confined to a specific region, as seen in Haskell's ST Monad. However, this can increase complexity and reduce code readability.

Linearity is proposed as a way to manage mutation while maintaining purity, but it presents challenges in practical implementation. The article also mentions functional farming, which tracks linearity at runtime, allowing for efficient in-place updates without exposing mutable state. However, this relies on reference counting, which may not be feasible for all languages.

Ultimately, the author suggests that while linearity shows promise, a new approach may be needed to effectively integrate mutation into functional programming, ensuring it remains user-friendly and compatible with existing state management solutions.