• @RageAgainstTheRich
    link
    3
    edit-2
    9 months ago

    That is a… strange take.

    Random example, imagine a variable that holds the time of the last time the user moved the mouse. Or in a game holding the current selected target of the player. Or the players gold amount. Or its level. Or health. Or current position.

      • @RageAgainstTheRich
        link
        19 months ago

        Legit question because i think I’m misunderstanding. But if its a const, how are you able to swap or replace it?

        • @[email protected]
          link
          fedilink
          59 months ago

          It’s only a const within a function. You can pass the value to another function and changing it as it’s passed. For example:

          const int foo = 1
          other_func( foo + 1)
          

          In functional programming, you tend to keep track of state on the stack like this.

          • @madcaesar
            link
            19 months ago

            What is the advantage of this VS just overwriting the var?

            • @[email protected]
              link
              fedilink
              79 months ago

              Keeping state managed. The data for the function will be very predictable. This is especially important when it comes to multithreading. You can’t have a race condition where two things update the same data when they never update it that way at all.

              • @madcaesar
                link
                19 months ago

                Hm I’m having trouble visualizing this do you know a quick little example to illustrate this?

                • @[email protected]
                  link
                  fedilink
                  19 months ago

                  Rather than me coming up with an elaborate and contrived example, I suggest giving a language like Elixir a try. It tends to force you into thinking in terms of immutability. Bit of a learning curve if you’re not used to it, but it just takes practice.

                  • @madcaesar
                    link
                    19 months ago

                    Ok how about this then, I frequently do something like this:

                    let className = 'btn'
                      if (displayType) {
                        className += ` ${displayType}`
                      }
                      if (size) {
                        className += ` ${size}`
                      }
                      if (bordered) {
                        className += ' border'
                      }
                      if (classNameProp) {
                        className += ` ${classNameProp}`
                      }
                    

                    How would this be made better with a functional approach? And would be more legible, better in anyway?