Who actually hates on declarative/immutable distros as a concept? Its always the actual usability of the specific implementations thats the problem. Stale packages, poor documentation.

Its like if subroutine bar could say its going to execute at line N of routine foo. But if you were just reading foo then you’d have no clue that it would happen.

You can simulate this effect with bad inheritance patterns.

My method names are the same way but I aggressively sort things into modules etc so it comes out the other way.

But if I was staring down dozens of these methods and no way to organize them, I’d start doing the sorted names just for ease of editing. L

Running and LSP on a monorepo will destroy those 4gigs no problem.

No. Persistent Data Structures are not mutable. The memory space of an older version is not rewritten, it is referenced by the newer version as a part of its definition. ie via composition. It can only safely do this if the data it references is guaranteed to not change.

x = 2 :: 1 :: Nil -- [2, 1]
y = 3 :: x -- [3, 2, 1]

In this example both x and y are single linked lists. y is a node with value 3 and a pointer to x. If x was mutable then changing x would change y. That’s bad™ so its not allowed.

If you want to learn more about functional programming I suggest reading Structures and Interpretation of Computer Programs or Learn You a Haskell for Great Good

Very standard use case for a fold or reduce function with an immutable Map as the accumulator

val ints = List(1, 2, 2, 3, 3, 3)
val sum = ints.foldLeft(0)(_ + _) // 14
val counts = ints.foldLeft(Map.empty[Int, Int])((c, x) => {
  c.updated(x , c.getOrElse(x, 0) + 1)
})

foldLeft is a classic higher order function. Every functional programming language will have this plus multiple variants of it in their standard library. Newer non-functional programing languages will have it too. Writing implementations of foldLeft and foldRight is standard for learning recursive functions.

The lambda is applied to the initial value (0 or Map.empty[Int, Int]) and the first item in the list. The return type of the lambda must be the same type as the initial value. It then repeats the processes on the second value in the list, but using the previous result, and so on until theres no more items.

In the example above, c will change like you’d expect a mutable solution would but its a new Map each time. This might sound inefficient but its not really. Because each Map is immutable it can be optimized to share memory of the past Maps it was constructed from. Thats something you absolutely cannot do if your structures are mutable.

You avoid having mutable state as much as possible. This is a pretty standard concept these days.

✅

Immutable members. Set in constructor then read only. The Builder pattern is acceptable if you’re language is an obstacle.

Manic episode, part 3

Literally Firefox in the dock…