• sudo@programming.dev
            link
            fedilink
            arrow-up
            7
            arrow-down
            4
            ·
            7 months ago

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

              • sudo@programming.dev
                link
                fedilink
                arrow-up
                2
                ·
                7 months ago

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

                • Piafraus@lemmy.world
                  link
                  fedilink
                  arrow-up
                  2
                  ·
                  7 months ago

                  Can you please give me an example - let’s say I have a big list of numbers and I need to find how many times each number is there.

                  I would expect a mutable dictionary/map and a single pass through. How would you do that without mutable datastructure?

                  • sudo@programming.dev
                    link
                    fedilink
                    arrow-up
                    2
                    ·
                    edit-2
                    7 months ago

                    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.