News for hackers. Stuff that matters.
Re:Why Functional Programming Should Be the Future of Software by colonwqbang on Wednesday November 02, 2022 @10:37AM (#33436522)
Efficient functional programming often uses tree-like data structures. These can be immutable but still avoid duplication.

Consider if you "duplicate" a Data.Sequence Seq (finger tree) for modification. You're not actually copying the whole structure, you are creating a new root node and re-using as much as possible of the common structure.

The end result is that a bit more memory is used in the simplest case, but not due to duplication I think.

The benefit is that a thread can make a modified value at cheaper cost without affecting another thread that is still using the original value. I also think it's easier for the programmer to understand the code.

Re:Why Functional Programming Should Be the Future of Software by skohan on Wednesday November 02, 2022 @11:19AM (#33437255)
Won't this still result in a lot of fragmentation? I.e. won't you have disjoint allocations for those new branches of the tree? Sounds pretty cache-unfriendly.
Re:Why Functional Programming Should Be the Future of Software by hither_shores on Wednesday November 02, 2022 @01:48PM (#33440012)
In a strict language or with poorly optimized lazy code, yes. If you can get good stream fusion, not really. If your code fuses really well (common for lists, harder elsewhere) the whole thing will happen on the stack.
Re:Why Functional Programming Should Be the Future of Software by AnimalMuppet on Wednesday November 02, 2022 @01:23PM (#33439558)
That's duplicating part of the structure. That uses more memory than just modifying a value in-place, but less than duplicating the whole tree.
Re:Why Functional Programming Should Be the Future of Software by colonwqbang on Friday November 04, 2022 @06:41AM (#33464455)
Sure, but let's assume that the program has more than one thread and that another thread could still be using the old value. In that case, an imperative program might be required to copy the whole structure or sleep until the existing users are done, which is often less efficient and is always more complicated.

If it's ok to support only a single concurrent user of the value, then a mutable structure is more efficient. Even in Haskell we have mutable structures that can be used for such purposes.

The interesting question to me is, what should be the default? I think there is a good argument that it should be the safer, simpler immutable structures.

Re:Why Functional Programming Should Be the Future of Software by AnimalMuppet on Friday November 04, 2022 @07:49PM (#33475790)
"Simpler". If you're only single-threaded, the mutable structures are simpler.

If you're multi-threaded, you have to choose: Do I go with immutable, which means that the other thread gets something safe? It also means that the other thread gets something stale (out of date), which can have its own consequences.

Or do I use a lock or mutex, which means that I have to place guards in all the right places, which is error-prone and can break in weird ways if I miss one?

Or do I use mutable data without guards, and just let it crash? (Because it's probably going to crash if I do that...)