Impure Languages in the Functional Paradigm: An Exploration

It's a common misconception that impure languages, such as Erlang, Elixir, or LFE, do not belong in the functional programming realm. However, these languages, often referred to as functional-first but impure, offer a wealth of tools to work with functional constructs, making them well-suited for functional programming.

Understanding Functional-First Impure Languages

Functional-first languages, such as Clojure, Scala, OCaml, F#, and Scheme, emphasize a functional approach to programming. Despite allowing mutability and side effects, they provide abundant tools to write idiomatic functional code. For instance, Erlang, Elixir, and LFE are often categorized as functional due to their comprehensive functional libraries and support for functional programming features like higher-order functions, algebraic data types (ADTs), and tail call optimization (TCO).

Examples and Comparisons

Take Kotlin, which has functional features even if not strictly an impure functional language. However, it still supports functional programming principles, making it a versatile choice for developers. By contrast, a pure functional language like Haskell strictly separates state and uses monads for mutable state handling, whereas languages like OCaml and Scala are more flexible, allowing side effects within their frameworks. This contrasts with purely imperative languages such as C and Python, which lack the built-in support for functional constructs.

Functional vs. Procedural: A Non-Comparison

Functional and procedural programming are so fundamentally different that comparing them is like comparing apples to garages. Functional programming emphasizes immutability, higher-order functions, and declarative code, while procedural programming focuses on imperative code and side effects. Here’s a side-by-side look at sum calculation in various languages to illustrate these differences:

Sum of Squares in Different Languages

1. C/C (Imperative)

int sum_of_squares(int n) {    int sum  0;    for (int i  n; i  0; i--) {        sum   i * i;    }    return sum;}

2. Python (Procedural)

iterative:
def sumOfSquares1(n):
    return sum(x * x for x in range(n))
recursive:
def sumOfSquares2(n):
    sum  0
    for x in range(n):
        sum  x * x
    return sum

3. Haskell (Functional)

Iterative:

sumOfSquares :: Int - IntsumOfSquares n  foldl (acc x - acc   x * x) 0 [0..n]

Recursive:

sumOfSquares :: Int - IntsumOfSquares 0  0sumOfSquares n  n * n   sumOfSquares (n - 1)

Functional Filter Implementation in C and Python

C 11/14

templatetypename Tstd::vectorT filter(bool (*fn)(T), std::vectorT list) {    std::vectorT ret;    for (T entry : list) {        if (fn(entry)) {            ret.push_back(entry);        }    }    return ret;}

Python

def filter(fn, iter):    return (i for i in iter if fn(i))def filter(fn, iter):    return [i for i in iter if fn(i)]

Compared to these procedural and functional implementations, impure functional languages like Erlang offer a more functional approach, making them versatile for developers who embrace functional programming paradigms.

Conclusion

While impure languages like Erlang, LFE, and Elixir may not be as rigidly functional as languages like Haskell, they provide a robust environment for writing functional code. The key is to leverage the functional features provided by these languages while embracing the flexibility they offer in terms of handling side effects and mutability.